From 9e4e7540b7cc03acbd75740511e922914b4200c8 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Mon, 6 Nov 2023 17:34:36 +0800
Subject: [PATCH 01/11] [LoongArch64] add Intrinsics' API for LoongArch64.

---
 .../LA64Base.PlatformNotSupported.cs          |  217 ++
 .../Intrinsics/LoongArch64/LA64Base.cs        |  212 ++
 .../LA_LASX.PlatformNotSupported.cs           | 2273 +++++++++++++++
 .../Runtime/Intrinsics/LoongArch64/LA_LASX.cs | 2269 +++++++++++++++
 .../LA_LSX.PlatformNotSupported.cs            | 2554 +++++++++++++++++
 .../Runtime/Intrinsics/LoongArch64/LA_LSX.cs  | 2552 ++++++++++++++++
 .../ref/System.Runtime.Intrinsics.cs          |  838 ++++++
 7 files changed, 10915 insertions(+)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..3017218463aff6
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs
@@ -0,0 +1,217 @@
+// 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.LoongArch64
+{
+    /// <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 LA64Base
+    {
+        internal LA64Base() { }
+
+        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.D rd, rj
+        /// </summary>
+        public static int LeadingSignCount(long 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: 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: FSQRT.S fd, fj
+        /// </summary>
+        public static float SquareRoot(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: FSQRT.D fd, fj
+        /// </summary>
+        public static double SquareRoot(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: FRECIP.S fd, fj
+        /// </summary>
+        public static float Reciprocal(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: FRECIP.D fd, fj
+        /// </summary>
+        public static double Reciprocal(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: FRSQRT.S fd, fj
+        /// </summary>
+        public static float ReciprocalSqrt(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: FRSQRT.D fd, fj
+        /// </summary>
+        public static double ReciprocalSqrt(double value) { throw new PlatformNotSupportedException(); }
+
+#if false
+        // TODO-LA: adding  bstrins, bstrpick, bytepick
+        /// <summary>
+        ///   LA64: BYTEPICK.W rd, rj, sa2
+        /// </summary>
+        public static int SpliceAndCutBits(int left, int right, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BYTEPICK.W rd, rj, sa2
+        /// </summary>
+        public static uint SpliceAndCutBits(uint left, uint right, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BYTEPICK.D rd, rj, sa3
+        /// </summary>
+        public static long SpliceAndCutBits(long left, long right, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BYTEPICK.D rd, rj, sa3
+        /// </summary>
+        public static ulong SpliceAndCutBits(ulong left, ulong right, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static int ReplaceBits(int left, int right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static uint ReplaceBits(uint left, uint right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static long ReplaceBits(long left, long right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static ulong ReplaceBits(ulong left, ulong right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static int CutBits(int left, int right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static uint CutBits(uint left, uint right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static long CutBits(long left, long right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static ulong CutBits(ulong left, ulong right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+#endif
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs
new file mode 100644
index 00000000000000..fbb4a35f4a3ea7
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs
@@ -0,0 +1,212 @@
+// 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.LoongArch64
+{
+    /// <summary>
+    /// This class provides access to the LA64 base hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class LA64Base
+    {
+        internal LA64Base() { }
+
+        public static bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        ///   LA64: CLO.W rd, rj
+        /// </summary>
+        public static int LeadingSignCount(int value) => LeadingSignCount(value);
+
+        /// <summary>
+        ///   LA64: CLO.D rd, rj
+        /// </summary>
+        public static int LeadingSignCount(long 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: 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: FSQRT.S fd, fj
+        /// </summary>
+        public static float SquareRoot(float value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA64: FSQRT.D fd, fj
+        /// </summary>
+        public static double SquareRoot(double value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA64: FRECIP.S fd, fj
+        /// </summary>
+        public static float Reciprocal(float value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA64: FRECIP.D fd, fj
+        /// </summary>
+        public static double Reciprocal(double value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA64: FRSQRT.S fd, fj
+        /// </summary>
+        public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        ///   LA64: FRSQRT.D fd, fj
+        /// </summary>
+        public static double ReciprocalSqrt(double value) => ReciprocalSqrt(value);
+
+#if false
+        // TODO-LA: adding  bstrins, bstrpick, bytepick
+        /// <summary>
+        ///   LA64: BYTEPICK.W rd, rj, sa2
+        /// </summary>
+        public static int SpliceAndCutBits(int left, int right, uint start) => SpliceAndCutBits(left, right, start);
+
+        /// <summary>
+        ///   LA64: BYTEPICK.W rd, rj, sa2
+        /// </summary>
+        public static uint SpliceAndCutBits(uint left, uint right, uint start) => SpliceAndCutBits(left, right, start);
+
+        /// <summary>
+        ///   LA64: BYTEPICK.D rd, rj, sa3
+        /// </summary>
+        public static long SpliceAndCutBits(long left, long right, uint start) => SpliceAndCutBits(left, right, start);
+
+        /// <summary>
+        ///   LA64: BYTEPICK.D rd, rj, sa3
+        /// </summary>
+        public static ulong SpliceAndCutBits(ulong left, ulong right, uint start) => SpliceAndCutBits(left, right, start);
+
+        /// <summary>
+        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static int ReplaceBits(int left, int right, uint end, uint start) => ReplaceBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static uint ReplaceBits(uint left, uint right, uint end, uint start) => ReplaceBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static long ReplaceBits(long left, long right, uint end, uint start) => ReplaceBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static ulong ReplaceBits(ulong left, ulong right, uint end, uint start) => ReplaceBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static int CutBits(int left, int right, uint end, uint start) => CutBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        /// </summary>
+        public static uint CutBits(uint left, uint right, uint end, uint start) => CutBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static long CutBits(long left, long right, uint end, uint start) => CutBits(left, right, end, start);
+
+        /// <summary>
+        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
+        /// </summary>
+        public static ulong CutBits(ulong left, ulong right, uint end, uint start) => CutBits(left, right, end, start);
+#endif
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..2a754eeacc9c6a
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs
@@ -0,0 +1,2273 @@
+// 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.LoongArch64
+{
+    /// <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 LA_LASX : LA_LSX
+    {
+        internal LA_LASX() { }
+
+        public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+        /// <summary>
+        /// int8x32_t xvadd_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvadd_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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 xvsub_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsub_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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>
+        /// int8x32_t xvmul_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULW Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmul_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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 xvdiv_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvdiv_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvdiv_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// float32x8_t xvfmadd_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAdd(Vector256<float> addend, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmadd_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAdd(Vector256<double> addend, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmadd_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t TODO_s8 (int8x32_t a, uint8x32_t b)
+        ///   LASX: TODO Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8x32_t a, int8x32_t b)
+        ///   LASX: TODO Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t TODO_s16 (int16x16_t a, uint16x16_t b)
+        ///   LASX: TODO Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t TODO_u16 (uint16x16_t a, int16x16_t b)
+        ///   LASX: TODO Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t TODO_s32 (int32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, int32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t TODO_s64 (int64x4_t a, uint64x4_t b)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t TODO_u64 (uint64x4_t a, int64x4_t b)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsadd_b_s8 (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_s16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsadd_d_s64 (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_u8 (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_u16 (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_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSADD.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsadd_du_u64 (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>
+        /// int8x32_t xvmsub_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmaddwev_h_b_s8 (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_u8 (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_s16 (int32x8_t a, int16x4_t b, int16x4_t c)
+        ///   LASX: XVMADDWEV.W.H Xd.8S, 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_u16 (uint32x8_t a, uint16x4_t b, uint16x4_t c)
+        ///   LASX: XVMADDWEV.W.HU Xd.8S, 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_s32 (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_u32 (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_s8 (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_u8 (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_s16 (int32x8_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADDWOD.W.H Xd.8S, 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_u16 (uint32x8_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADDWOD.W.HU Xd.8S, 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_s32 (int64x4_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> MultiplyWideningUpperAndAdd(Vector256<long> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmaddwod_d_wu_u32 (uint64x4_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvseq_b_s8 (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_u8 (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>
+        /// uint16x16_t xvseq_h_s16 (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_u16 (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>
+        /// uint32x8_t xvseq_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvseq_w_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvseq_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvslt_b_s8 (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_s8 (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_s16 (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_s16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu_s32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_d_s64 (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_s64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvsle_b_s8 (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>
+        /// uint8x32_t xvsle_bu_u8 (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_h_s16 (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>
+        /// uint16x16_t xvsle_hu_u16 (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_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_d_s64 (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>
+        /// uint64x4_t xvsle_du_u64 (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_f32 (float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d_f64 (float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsle_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvslt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_d_s64 (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_u64 (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_f32 (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_f64 (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 xvmax_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMAX.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmax_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMAX.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmax_d_s64 (int64x4_t a, int64x4_t b)
+        ///   LASX: XVMAX.D Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmax_du_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMAX.DU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmax_s_f32 (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_f64 (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>
+        /// int8x32_t xvmin_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMIN.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmin_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMIN.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmin_d_s64 (int64x4_t a, int64x4_t b)
+        ///   LASX: XVMIN.D Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmin_du_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMIN.DU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmin_s_f32 (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_f64 (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>
+        /// int8x32_t xvbitsel_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVABSD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvabsd_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVABSD.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvabsd_d_s64 (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_u64 (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_f32 (float32x8_t a, float32x8_t b)
+        ///   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_f64 (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_s8 (int8_t const * ptr)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvld_u8 (uint8_t const * ptr)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvld_s16 (int16_t const * ptr)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvld_s16 (uint16_t const * ptr)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvld_s32 (int32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvld_s32 (uint32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvld_s64 (int64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvld_u64 (uint64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvld_f32 (float32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvld_f64 (float64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrecip_s_f32 (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_f64 (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_f32 (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_f64 (float64x4_t a)
+        ///   LASX: XVFRSQRT.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> ReciprocalSqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_s8 (int8_t * ptr, int8x32_t val)
+        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(sbyte* address, Vector256<sbyte> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_u8 (uint8_t * ptr, uint8x32_t val)
+        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(byte* address, Vector256<byte> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_s16 (int16_t * ptr, int16x16_t val)
+        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(short* address, Vector256<short> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_u16 (uint16_t * ptr, uint16x16_t val)
+        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ushort* address, Vector256<ushort> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_s32 (int32_t * ptr, int32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(int* address, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_u32 (uint32_t * ptr, uint32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(uint* address, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_s64 (int64_t * ptr, int64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(long* address, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_u64 (uint64_t * ptr, uint64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ulong* address, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_f32 (float32_t * ptr, float32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(float* address, Vector256<float> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst_f64 (float64_t * ptr, float64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(double* address, Vector256<double> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvneg_b_s8 (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_s16 (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_s32 (int32x8_t a)
+        ///   LASX: XVNEG.W Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<int> Negate(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvneg_d_s64 (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 TODO_f32 (float32x8_t a)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Negate(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t TODO_f64 (float64x4_t a)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Negate(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmsub_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtract(Vector256<float> minuend, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmsub_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtract(Vector256<double> minuend, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmulwod_h_b_s8 (int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningUpper(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmulwod_h_bu_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningUpper(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmulwod_w_h_s16 (int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningUpper(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmulwod_w_hu_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningUpper(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmulwod_d_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> MultiplyWideningUpper(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmulwod_d_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpper(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvssub_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssub_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSSUB.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvssub_d_s64 (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_u64 (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 xvavg_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVG.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvavg_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVG.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvavg_d_s64 (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_u64 (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>
+        /// int16x16_t xvexth_h_b_s8 (int8x32_t a)
+        ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvexth_w_h_s16 (int16x16_t a)
+        ///   LASX: XVEXTH.W.H Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvexth_d_w_s32 (int32x8_t a)
+        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpper(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvand_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x32_t xvxor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvslli_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslli_w_s32 (uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvslli_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrai_b_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrai_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrai_w_s32 (int32x8_t a, const int n)
+        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsrai_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrari_b_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrari_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrari_w_s32 (int32x8_t a, const int n)
+        ///   LASX: XVSRARI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsrari_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvadda_b_s8 (int8x32_t a)
+        ///   LASX: XVADDA.B Xd.32B, Xd.32B, 0
+        /// </summary>
+        public static Vector256<byte> Abs(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvadda_h_s16 (int16x16_t a)
+        ///   LASX: XVADDA.H Xd.16H, Xd.16H, 0
+        /// </summary>
+        public static Vector256<ushort> Abs(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvadda_w_s32 (int32x8_t a)
+        ///   LASX: XVADDA.W Xd.8S, Xd.8S, 0
+        /// </summary>
+        public static Vector256<uint> Abs(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvadda_d_s64 (int64xx_t a)
+        ///   LASX: XVADDA.D Xd.4D, Xd.4D, 0
+        /// </summary>
+        public static Vector256<ulong> Abs(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvbitclri_w_f32 (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_f64 (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 xvfsqrt_s_f32 (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_f64 (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 xvfrintrm_s_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t TODO_s8 (int8_t a, int8x32_t v, const int imm)
+        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector256<sbyte> Insert(Vector256<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8_t a, uint8x32_t v, const int imm)
+        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector256<byte> Insert(Vector256<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t TODO_s16 (int16_t a, int16x16_t v, const int imm)
+        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector256<short> Insert(Vector256<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t TODO_u16 (uint16_t a, uint16x16_t v, const int imm)
+        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector256<ushort> Insert(Vector256<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvinsgr2vr_w_s32 (int32_t a, int32x8_t v, const int imm)
+        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector256<int> Insert(Vector256<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvinsgr2vr_w_u32 (uint32_t a, uint32x8_t v, const int imm)
+        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector256<uint> Insert(Vector256<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvinsgr2vr_d_s64 (int64_t a, int64x4_t v, const int imm)
+        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector256<long> Insert(Vector256<long> vector, byte index, long data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvinsgr2vr_d_u64 (uint64_t a, uint64x4_t v, const int imm)
+        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector256<ulong> Insert(Vector256<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvinsve0_w_f32 (float32_t a, float32x8_t v, const int imm)
+        ///   LASX: XVINSVE0.W Xd.S[imm], Xj.S[0], imm
+        /// </summary>
+        public static Vector256<float> Insert(Vector256<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvinsve0_d_f64 (float64_t a, float64x4_t v, const int imm)
+        ///   LASX: XVINSVE0.D Xd.D[imm], Xj.D[0], imm
+        /// </summary>
+        public static Vector256<double> Insert(Vector256<double> vector, byte index, double data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvreplgr2vr_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// </summary>
+        public static Vector256<int> DuplicateToVector256(int value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvreplgr2vr_w_u32 (uint32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// </summary>
+        public static Vector256<uint> DuplicateToVector256(uint value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvreplgr2vr_d_s64 (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_u64 (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_f32 (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_f64 (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_f32_s32 (int32x8_t a)
+        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvffint_s_wu_f32_u32 (uint32x8_t a)
+        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvffint_d_l_f64_s64 (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_f64_u64 (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_u8 (uint8x32_t value)
+        ///   LASX: XVSETNEZ.V cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvseteqz_v_u8 (uint8x32_t value)
+        ///   LASX: XVSETEQZ.V cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_b_s8 (int8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_b_u8 (uint8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_h_s16 (int16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_h_u16 (uint16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w_s32 (int32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w_u32 (uint32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w_s64 (int64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w_u64 (uint64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_b_s8 (int8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_b_u8 (uint8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_h_s16 (int16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_h_u16 (uint16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_s32 (int32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_u32 (uint32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_s64 (int64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_u64 (uint64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvpcnt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (uint64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<ulong> PopCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs
new file mode 100644
index 00000000000000..84700b834b2122
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs
@@ -0,0 +1,2269 @@
+// 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.LoongArch64
+{
+    /// <summary>
+    /// This class provides access to the LASX-256bits hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class LA_LASX : LA_LSX
+    {
+        internal LA_LASX() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// int8x32_t xvadd_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x4_t xvadd_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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 xvsub_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int64x4_t xvsub_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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>
+        /// int8x32_t xvmul_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULW Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmul_d_s64 (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 TODO_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: TODO 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_f32 (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_f64 (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 xvdiv_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvdiv_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) => Divide(left, right);
+
+        /// <summary>
+        /// int64x4_t xvdiv_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// float32x8_t xvfmadd_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAdd(Vector256<float> addend, Vector256<float> left, Vector256<float> right) => FusedMultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmadd_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAdd(Vector256<double> addend, Vector256<double> left, Vector256<double> right) => FusedMultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int8x32_t xvmadd_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int8x32_t TODO_s8 (int8x32_t a, uint8x32_t b)
+        ///   LASX: TODO Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<byte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8x32_t a, int8x32_t b)
+        ///   LASX: TODO Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<sbyte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x16_t TODO_s16 (int16x16_t a, uint16x16_t b)
+        ///   LASX: TODO Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<ushort> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint16x16_t TODO_u16 (uint16x16_t a, int16x16_t b)
+        ///   LASX: TODO Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<short> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int32x8_t TODO_s32 (int32x8_t a, uint32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, int32x8_t b)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x4_t TODO_s64 (int64x4_t a, uint64x4_t b)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<ulong> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x4_t TODO_u64 (uint64x4_t a, int64x4_t b)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<long> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int8x32_t xvsadd_b_s8 (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_s16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSADD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x4_t xvsadd_d_s64 (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_u8 (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_u16 (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_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSADD.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsadd_du_u64 (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>
+        /// int8x32_t xvmsub_b_s8 (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 TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: TODO 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_s16 (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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: TODO 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmaddwev_h_b_s8 (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_u8 (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_s16 (int32x8_t a, int16x4_t b, int16x4_t c)
+        ///   LASX: XVMADDWEV.W.H Xd.8S, 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_u16 (uint32x8_t a, uint16x4_t b, uint16x4_t c)
+        ///   LASX: XVMADDWEV.W.HU Xd.8S, 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_s32 (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_u32 (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_s8 (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_u8 (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_s16 (int32x8_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADDWOD.W.H Xd.8S, 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_u16 (uint32x8_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADDWOD.W.HU Xd.8S, 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_s32 (int64x4_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// </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_u32 (uint64x4_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x32_t xvseq_b_s8 (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_u8 (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>
+        /// uint16x16_t xvseq_h_s16 (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_u16 (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>
+        /// uint32x8_t xvseq_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvseq_w_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvseq_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvslt_b_s8 (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_s8 (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_s16 (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_s16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu_s32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_d_s64 (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_s64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvsle_b_s8 (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>
+        /// uint8x32_t xvsle_bu_u8 (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_h_s16 (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>
+        /// uint16x16_t xvsle_hu_u16 (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_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_d_s64 (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>
+        /// uint64x4_t xvsle_du_u64 (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_f32 (float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d_f64 (float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvsle_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// uint8x32_t xvslt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_d_s64 (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_u64 (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_f32 (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_f64 (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 xvmax_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMAX.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) => Max(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmax_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMAX.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) => Max(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmax_d_s64 (int64x4_t a, int64x4_t b)
+        ///   LASX: XVMAX.D Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) => Max(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmax_du_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMAX.DU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmax_s_f32 (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_f64 (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>
+        /// int8x32_t xvmin_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMIN.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) => Min(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmin_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMIN.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) => Min(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmin_d_s64 (int64x4_t a, int64x4_t b)
+        ///   LASX: XVMIN.D Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) => Min(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmin_du_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMIN.DU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmin_s_f32 (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_f64 (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>
+        /// int8x32_t xvbitsel_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVABSD.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvabsd_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVABSD.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int64x4_t xvabsd_d_s64 (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_u64 (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_f32 (float32x8_t a, float32x8_t b)
+        ///   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_f64 (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_s8 (int8_t const * ptr)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address) => LoadVector256(address);
+
+        /// <summary>
+        /// uint8x32_t xvld_u8 (uint8_t const * ptr)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address) => LoadVector256(address);
+
+        /// <summary>
+        /// int16x16_t xvld_s16 (int16_t const * ptr)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address) => LoadVector256(address);
+
+        /// <summary>
+        /// uint16x16_t xvld_s16 (uint16_t const * ptr)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address) => LoadVector256(address);
+
+        /// <summary>
+        /// int32x8_t xvld_s32 (int32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address) => LoadVector256(address);
+
+        /// <summary>
+        /// uint32x8_t xvld_s32 (uint32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address) => LoadVector256(address);
+
+        /// <summary>
+        /// int64x4_t xvld_s64 (int64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address) => LoadVector256(address);
+
+        /// <summary>
+        /// uint64x4_t xvld_u64 (uint64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address) => LoadVector256(address);
+
+        /// <summary>
+        /// float32x8_t xvld_f32 (float32_t const * ptr)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address) => LoadVector256(address);
+
+        /// <summary>
+        /// float64x4_t xvld_f64 (float64_t const * ptr)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address) => LoadVector256(address);
+
+        /// <summary>
+        /// float32x8_t xvfrecip_s_f32 (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_f64 (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_f32 (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_f64 (float64x4_t a)
+        ///   LASX: XVFRSQRT.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> ReciprocalSqrt(Vector256<double> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// void xvst_s8 (int8_t * ptr, int8x32_t val)
+        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(sbyte* address, Vector256<sbyte> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_u8 (uint8_t * ptr, uint8x32_t val)
+        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(byte* address, Vector256<byte> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_s16 (int16_t * ptr, int16x16_t val)
+        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(short* address, Vector256<short> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_u16 (uint16_t * ptr, uint16x16_t val)
+        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ushort* address, Vector256<ushort> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_s32 (int32_t * ptr, int32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(int* address, Vector256<int> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_u32 (uint32_t * ptr, uint32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(uint* address, Vector256<uint> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_s64 (int64_t * ptr, int64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(long* address, Vector256<long> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_u64 (uint64_t * ptr, uint64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ulong* address, Vector256<ulong> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_f32 (float32_t * ptr, float32x8_t val)
+        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source);
+
+        /// <summary>
+        /// void xvst_f64 (float64_t * ptr, float64x4_t val)
+        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(double* address, Vector256<double> source) => Store(address, source);
+
+        /// <summary>
+        /// int8x32_t xvneg_b_s8 (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_s16 (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_s32 (int32x8_t a)
+        ///   LASX: XVNEG.W Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<int> Negate(Vector256<int> value) => Negate(value);
+
+        /// <summary>
+        /// int64x4_t xvneg_d_s64 (int64x4_t a)
+        ///   LASX: XVNEG.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> Negate(Vector256<long> value) => Negate(value);
+
+        /// <summary>
+        /// float32x8_t TODO_f32 (float32x8_t a)
+        ///   LASX: TODO Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Negate(Vector256<float> value) => Negate(value);
+
+        /// <summary>
+        /// float64x4_t TODO_f64 (float64x4_t a)
+        ///   LASX: TODO Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Negate(Vector256<double> value) => Negate(value);
+
+        /// <summary>
+        /// float32x8_t xvfmsub_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtract(Vector256<float> minuend, Vector256<float> left, Vector256<float> right) => FusedMultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmsub_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtract(Vector256<double> minuend, Vector256<double> left, Vector256<double> right) => FusedMultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmulwod_h_b_s8 (int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningUpper(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmulwod_h_bu_u8 (uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningUpper(Vector256<byte> left, Vector256<byte> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmulwod_w_h_s16 (int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningUpper(Vector256<short> left, Vector256<short> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmulwod_w_hu_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningUpper(Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmulwod_d_w_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<long> MultiplyWideningUpper(Vector256<int> left, Vector256<int> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmulwod_d_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpper(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int8x32_t xvssub_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVSSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvssub_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSSUB.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int64x4_t xvssub_d_s64 (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_u64 (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 xvavg_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVG.W Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) => Average(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvavg_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVG.WU Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) => Average(left, right);
+
+        /// <summary>
+        /// int64x4_t xvavg_d_s64 (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_u64 (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>
+        /// int16x16_t xvexth_h_b_s8 (int8x32_t a)
+        ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int32x8_t xvexth_w_h_s16 (int16x16_t a)
+        ///   LASX: XVEXTH.W.H Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int64x4_t xvexth_d_w_s32 (int32x8_t a)
+        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpper(Vector256<uint> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int8x32_t xvand_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x32_t xvxor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint8x32_t xvslli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// int16x16_t xvslli_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint16x16_t xvslli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvslli_w_s32 (uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvslli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// int64x4_t xvslli_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint64x4_t xvslli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// int8x32_t xvsrai_b_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int16x16_t xvsrai_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int32x8_t xvsrai_w_s32 (int32x8_t a, const int n)
+        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int64x4_t xvsrai_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int8x32_t xvsrari_b_s8 (int8x32_t a, const int n)
+        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, #n
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int16x16_t xvsrari_h_s16 (int16x16_t a, const int n)
+        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, #n
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int32x8_t xvsrari_w_s32 (int32x8_t a, const int n)
+        ///   LASX: XVSRARI.W Xd.8S, Xj.8S, #n
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int64x4_t xvsrari_d_s64 (int64x4_t a, const int n)
+        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, #n
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int8x32_t xvadda_b_s8 (int8x32_t a)
+        ///   LASX: XVADDA.B Xd.32B, Xd.32B, 0
+        /// </summary>
+        public static Vector256<byte> Abs(Vector256<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x16_t xvadda_h_s16 (int16x16_t a)
+        ///   LASX: XVADDA.H Xd.16H, Xd.16H, 0
+        /// </summary>
+        public static Vector256<ushort> Abs(Vector256<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x8_t xvadda_w_s32 (int32x8_t a)
+        ///   LASX: XVADDA.W Xd.8S, Xd.8S, 0
+        /// </summary>
+        public static Vector256<uint> Abs(Vector256<int> value) => Abs(value);
+
+        /// <summary>
+        /// int64x4_t xvadda_d_s64 (int64xx_t a)
+        ///   LASX: XVADDA.D Xd.4D, Xd.4D, 0
+        /// </summary>
+        public static Vector256<ulong> Abs(Vector256<long> value) => Abs(value);
+
+        /// <summary>
+        /// float32x8_t xvbitclri_w_f32 (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_f64 (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 xvfsqrt_s_f32 (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_f64 (float64x4_t a)
+        ///   LASX: XVFSQRT.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Sqrt(Vector256<double> value) => Sqrt(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrm_s_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_s8 (int8_t a, int8x32_t v, const int imm)
+        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector256<sbyte> Insert(Vector256<sbyte> vector, byte index, sbyte data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint8x32_t TODO_u8 (uint8_t a, uint8x32_t v, const int imm)
+        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector256<byte> Insert(Vector256<byte> vector, byte index, byte data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int16x16_t TODO_s16 (int16_t a, int16x16_t v, const int imm)
+        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector256<short> Insert(Vector256<short> vector, byte index, short data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint16x16_t TODO_u16 (uint16_t a, uint16x16_t v, const int imm)
+        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector256<ushort> Insert(Vector256<ushort> vector, byte index, ushort data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int32x8_t xvinsgr2vr_w_s32 (int32_t a, int32x8_t v, const int imm)
+        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector256<int> Insert(Vector256<int> vector, byte index, int data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint32x8_t xvinsgr2vr_w_u32 (uint32_t a, uint32x8_t v, const int imm)
+        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector256<uint> Insert(Vector256<uint> vector, byte index, uint data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int64x4_t xvinsgr2vr_d_s64 (int64_t a, int64x4_t v, const int imm)
+        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector256<long> Insert(Vector256<long> vector, byte index, long data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint64x4_t xvinsgr2vr_d_u64 (uint64_t a, uint64x4_t v, const int imm)
+        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector256<ulong> Insert(Vector256<ulong> vector, byte index, ulong data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// float32x8_t xvinsve0_w_f32 (float32_t a, float32x8_t v, const int imm)
+        ///   LASX: XVINSVE0.W Xd.S[imm], Xj.S[0], imm
+        /// </summary>
+        public static Vector256<float> Insert(Vector256<float> vector, byte index, float data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// float64x4_t xvinsve0_d_f64 (float64_t a, float64x4_t v, const int imm)
+        ///   LASX: XVINSVE0.D Xd.D[imm], Xj.D[0], imm
+        /// </summary>
+        public static Vector256<double> Insert(Vector256<double> vector, byte index, double data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int8x32_t xvreplgr2vr_b_s8 (int8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<sbyte> DuplicateToVector256(sbyte value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint8x32_t xvreplgr2vr_b_u8 (uint8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<byte> DuplicateToVector256(byte value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int16x16_t xvreplgr2vr_h_s16 (int16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<short> DuplicateToVector256(short value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint16x16_t xvreplgr2vr_h_u16 (uint16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<ushort> DuplicateToVector256(ushort value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int32x8_t xvreplgr2vr_w_s32 (int32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// </summary>
+        public static Vector256<int> DuplicateToVector256(int value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint32x8_t xvreplgr2vr_w_u32 (uint32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// </summary>
+        public static Vector256<uint> DuplicateToVector256(uint value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int64x4_t xvreplgr2vr_d_s64 (int64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<long> DuplicateToVector256(long value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint64x4_t xvreplgr2vr_d_u64 (uint64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<ulong> DuplicateToVector256(ulong value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// float32x8_t xvreplve0_w_f32 (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_f64 (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_f32_s32 (int32x8_t a)
+        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<int> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float32x8_t xvffint_s_wu_f32_u32 (uint32x8_t a)
+        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<uint> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float64x4_t xvffint_d_l_f64_s64 (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_f64_u64 (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_u8 (uint8x32_t value)
+        ///   LASX: XVSETNEZ.V cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector256<byte> value) => HasElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvseteqz_v_u8 (uint8x32_t value)
+        ///   LASX: XVSETEQZ.V cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector256<byte> value) => AllElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_b_s8 (int8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<sbyte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_b_u8 (uint8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<byte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_h_s16 (int16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<short> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_h_u16 (uint16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ushort> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w_s32 (int32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<int> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w_u32 (uint32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<uint> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w_s64 (int64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<long> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w_u64 (uint64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ulong> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_b_s8 (int8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<sbyte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_b_u8 (uint8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<byte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_h_s16 (int16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<short> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_h_u16 (uint16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ushort> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_s32 (int32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<int> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_u32 (uint32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<uint> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_s64 (int64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<long> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w_u64 (uint64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ulong> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// int8x32_t xvpcnt_b_s8 (int8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x32_t xvpcnt_b_u8 (uint8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<byte> PopCount(Vector256<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x16_t xvpcnt_h_s16 (int16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<short> PopCount(Vector256<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x16_t xvpcnt_h_u16 (uint16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<ushort> PopCount(Vector256<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x8_t xvpcnt_w_s32 (int32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<int> PopCount(Vector256<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x8_t xvpcnt_w_u32 (uint32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<uint> PopCount(Vector256<uint> value) => PopCount(value);
+
+        /// <summary>
+        /// int64x4_t xvpcnt_d_s64 (int64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<long> PopCount(Vector256<long> value) => PopCount(value);
+
+        /// <summary>
+        /// uint64x4_t xvpcnt_d_u64 (uint64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<ulong> PopCount(Vector256<ulong> value) => PopCount(value);
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..4989ca55312f8f
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs
@@ -0,0 +1,2554 @@
+// 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.LoongArch64
+{
+    /// <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 LA_LSX : LA64Base
+    {
+        internal LA_LSX() { }
+
+        public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+        /// <summary>
+        /// int8x16_t vadd_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vadd_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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>
+        /// int8x16_t vsub_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsub_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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>
+        /// int8x16_t vmul_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMULW Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmul_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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 vdiv_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vdiv_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vdiv_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// float32x4_t vfmadd_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmadd_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmadd_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t TODO_s8 (int8x16_t a, uint8x16_t b)
+        ///   LSX: TODO Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, int8x16_t b)
+        ///   LSX: TODO Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t TODO_s16 (int16x8_t a, uint16x8_t b)
+        ///   LSX: TODO Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t TODO_u16 (uint16x8_t a, int16x8_t b)
+        ///   LSX: TODO Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t TODO_s32 (int32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, int32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t TODO_s64 (int64x2_t a, uint64x2_t b)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t TODO_u64 (uint64x2_t a, int64x2_t b)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsadd_b_s8 (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_s16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsadd_d_s64 (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_u8 (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_u16 (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_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsadd_du_u64 (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>
+        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> HorizontalAdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> HorizontalAdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vadd_h_s16 (int16x8_t a, int16x8_t b)
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> HorizontalAdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vadd_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> HorizontalAdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vadd_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> HorizontalAdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> HorizontalAdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static sbyte HorizontalSum(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static byte HorizontalSum(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static short HorizontalSum(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static ushort HorizontalSum(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static int HorizontalSum(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static uint HorizontalSum(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static long HorizontalSum(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static ulong HorizontalSum(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_float_elements witin value.
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static float HorizontalSum(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_double_elements witin value.
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static double HorizontalSum(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmsub_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmaddwev_h_b_s8 (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_u8 (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_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
+        ///   LSX: VMADDWEV.W.H Vd.4S, 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_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
+        ///   LSX: VMADDWEV.W.HU Vd.4S, 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_s32 (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_u32 (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_s8 (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_u8 (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_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADDWOD.W.H Vd.4S, 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_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADDWOD.W.HU Vd.4S, 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_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmaddwod_d_wu_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vseq_b_s8 (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_u8 (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>
+        /// uint16x8_t vseq_h_s16 (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_u16 (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>
+        /// uint32x4_t vseq_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vseq_w_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vseq_d_s64 (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_u64 (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>
+        /// uint32x4_t vfcmp_ceq_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CEQ.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vfcmp_ceq_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_b_s8 (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_s8 (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_s16 (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_s16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_wu_s32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_d_s64 (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_s64 (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>
+        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_b_s8 (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>
+        /// uint8x16_t vsle_bu_u8 (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_h_s16 (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>
+        /// uint16x8_t vsle_hu_u16 (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_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_d_s64 (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>
+        /// uint64x2_t vsle_du_u64 (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>
+        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_b_s8 (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>
+        /// uint8x16_t vsle_bu_u8 (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_h_s16 (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>
+        /// uint16x8_t vsle_hu_u16 (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_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_d_s64 (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>
+        /// uint64x2_t vsle_du_u64 (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>
+        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_d_s64 (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_u64 (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>
+        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmax_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMAX.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmax_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMAX.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmax_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VMAX.D Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmax_du_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMAX.DU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmax_s_f32 (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_f64 (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>
+        /// int8x16_t vmin_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMIN.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmin_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMIN.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmin_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VMIN.D Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmin_du_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMIN.DU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmin_s_f32 (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_f64 (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>
+        /// int8x16_t vbitsel_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VABSD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vabsd_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VABSD.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vabsd_d_s64 (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_u64 (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_f32 (float32x4_t a, float32x4_t b)
+        ///   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_f64 (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_s8 (int8_t const * ptr)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vld_u8 (uint8_t const * ptr)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vld_s16 (int16_t const * ptr)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vld_s16 (uint16_t const * ptr)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vld_s32 (int32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vld_s32 (uint32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vld_s64 (int64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vld_u64 (uint64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vld_f32 (float32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vld_f64 (float64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrecip_s_f32 (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_f64 (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_f32 (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_f64 (float64x2_t a)
+        ///   LSX: VFRSQRT.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> ReciprocalSqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_s8 (int8_t * ptr, int8x16_t val)
+        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_u8 (uint8_t * ptr, uint8x16_t val)
+        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_s16 (int16_t * ptr, int16x8_t val)
+        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_u16 (uint16_t * ptr, uint16x8_t val)
+        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_s32 (int32_t * ptr, int32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_u32 (uint32_t * ptr, uint32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_s64 (int64_t * ptr, int64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_u64 (uint64_t * ptr, uint64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_f32 (float32_t * ptr, float32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst_f64 (float64_t * ptr, float64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vneg_b_s8 (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_s16 (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_s32 (int32x4_t a)
+        ///   LSX: VNEG.W Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> Negate(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vneg_d_s64 (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 TODO_f32 (float32x4_t a)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Negate(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t TODO_f64 (float64x2_t a)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Negate(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmsub_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmsub_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmulwod_h_b_s8 (int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmulwod_h_bu_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmulwod_w_h_s16 (int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningUpper(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmulwod_w_hu_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMULWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningUpper(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmulwod_d_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> MultiplyWideningUpper(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmulwod_d_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpper(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vssub_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssub_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSSUB.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vssub_d_s64 (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_u64 (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 vavg_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VAVG.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vavg_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVG.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vavg_d_s64 (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_u64 (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>
+        /// int16x8_t vext2xv_h_b_s8 (int8x16_t a)
+        ///   LSX: VEXT2XV.H.B Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> SignExtendWideningLower(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int32x4_t vext2xv_w_b_s8 (int8x16_t a)
+        /////   LSX: VEXT2XV.W.B Vd.4W, Vj.16B
+        ///// </summary>
+        //public static Vector128<int> SignExtendWideningLower(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vext2xv_d_b_s8 (int8x16_t a)
+        /////   LSX: VEXT2XV.D.B Vd.2D, Vj.16B
+        ///// </summary>
+        //public static Vector128<long> SignExtendWideningLower(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vext2xv_w_h_s16 (int16x8_t a)
+        ///   LSX: VEXT2XV.W.H Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningLower(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vext2xv_d_h_s16 (int16x8_t a)
+        /////   LSX: VEXT2XV.D.H Vd.2D, Vj.8H
+        ///// </summary>
+        //public static Vector128<long> SignExtendWideningLower(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vext2xv_d_w_s32 (int32x4_t a)
+        ///   LSX: VEXT2XV.D.W Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> SignExtendWideningLower(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vext2xv_hu_bu_u8 (uint8x16_t a)
+        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint32x4_t vext2xv_wu_bu_u8 (uint8x16_t a)
+        /////   LSX: VEXT2XV.WU.BU Vd.4W, Vj.16B
+        ///// </summary>
+        //public static Vector128<uint> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vext2xv_du_bu_u8 (uint8x16_t a)
+        /////   LSX: VEXT2XV.DU.BU Vd.2D, Vj.16B
+        ///// </summary>
+        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vext2xv_wu_hu_u16 (uint16x8_t a)
+        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningLower(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vext2xv_du_hu_u16 (uint16x8_t a)
+        /////   LSX: VEXT2XV.DU.HU Vd.2D, Vj.8H
+        ///// </summary>
+        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vext2xv_du_wu_u32 (uint32x4_t a)
+        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vexth_h_b_s8 (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_s16 (int16x8_t a)
+        ///   LSX: VEXTH.W.H Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vexth_d_w_s32 (int32x4_t a)
+        ///   LSX: VEXTH.D.W Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vexth_HU_BU_u8 (uint8x16_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_u8 (uint8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vand_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x16_t vor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x16_t vxor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (int8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vslli_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslli_w_s32 (uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vslli_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrai_b_s8 (int8x16_t a, const int n)
+        ///   LSX: VSRAI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrai_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSRAI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrai_w_s32 (int32x4_t a, const int n)
+        ///   LSX: VSRAI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrai_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSRAI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrari_b_s8 (int8x16_t a, const int n)
+        ///   LSX: VSRARI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrari_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSRARI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrari_w_s32 (int32x4_t a, const int n)
+        ///   LSX: VSRARI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrari_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSRARI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vadda_b_s8 (int8x16_t a)
+        ///   LSX: VADDA.B Vd.16B, Vd.16B, 0
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vadda_h_s16 (int16x8_t a)
+        ///   LSX: VADDA.H Vd.8H, Vd.8H, 0
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vadda_w_s32 (int32x4_t a)
+        ///   LSX: VADDA.W Vd.4S, Vd.4S, 0
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vdda_d_s64 (int64x2_t a)
+        ///   LSX: VADDA.D Vd.2D, Vd.2D, 0
+        /// </summary>
+        public static Vector128<ulong> Abs(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vbitclri_w_f32 (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_f64 (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 vfsqrt_s_f32 (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_f64 (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 vfrintrm_s_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_s8 (int8_t a, int8x16_t v, const int imm)
+        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vinsgr2vr_b_u8 (uint8_t a, uint8x16_t v, const int imm)
+        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vinsgr2vr_h_s16 (int16_t a, int16x8_t v, const int imm)
+        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector128<short> Insert(Vector128<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vinsgr2vr_h_u16 (uint16_t a, uint16x8_t v, const int imm)
+        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vinsgr2vr_w_s32 (int32_t a, int32x4_t v, const int imm)
+        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector128<int> Insert(Vector128<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vinsgr2vr_w_u32 (uint32_t a, uint32x4_t v, const int imm)
+        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vinsgr2vr_d_s64 (int64_t a, int64x2_t v, const int imm)
+        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector128<long> Insert(Vector128<long> vector, byte index, long data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vinsgr2vr_d_u64 (uint64_t a, uint64x2_t v, const int imm)
+        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t xvinsve0_w_f32 (float32_t a, float32x4_t v, const int imm)
+        ///   LSX: XVINSVE0.W Vd.S[imm], Vj.S[0], imm
+        /// </summary>
+        public static Vector128<float> Insert(Vector128<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t xvinsve0_d_f64 (float64_t a, float64x2_t v, const int imm)
+        ///   LSX: XVINSVE0.D Vd.D[imm], Vj.D[0], imm
+        /// </summary>
+        public static Vector128<double> Insert(Vector128<double> vector, byte index, double data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vreplgr2vr_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// </summary>
+        public static Vector128<int> DuplicateToVector128(int value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vreplgr2vr_w_u32 (uint32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// </summary>
+        public static Vector128<uint> DuplicateToVector128(uint value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vreplgr2vr_d_s64 (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_u64 (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_f32 (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_f64 (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_f32_s32 (int32x4_t a)
+        ///   LSX: VFFINT.S.W Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vffint_s_wu_f32_u32 (uint32x4_t a)
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vffint_d_l_f64_s64 (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_f64_u64 (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_u8 (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_u16 (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_u8 (uint8x16_t value)
+        ///   LSX: VSETNEZ.V cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vseteqz_v_u8 (uint8x16_t value)
+        ///   LSX: VSETEQZ.V cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_b_s8 (int8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_b_u8 (uint8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_h_s16 (int16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_h_u16 (uint16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w_s32 (int32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w_u32 (uint32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w_s64 (int64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w_u64 (uint64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_b_s8 (int8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_b_u8 (uint8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_h_s16 (int16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_h_u16 (uint16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w_s32 (int32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w_u32 (uint32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w_s64 (int64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        /// <summary>
+        /// bool vsetanyeqz_w_u64 (uint64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_b_h_16 (int16x8_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_b_h_u16 (uint16x8_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_h_w_s32 (int32x4_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_h_w_u32 (uint32x4_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_w_d_s64 (int64x2_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<long> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// ulong vsrlni_w_d_u64 (uint64x2_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ulong> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16 vsrlni_b_h_u16 (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 vsrlni_h_w_s32 (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 vsrlni_h_w_u32 (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 vsrlni_w_d_s64 (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 vsrlni_w_d_u64 (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>
+        /// int8x16_t vpcnt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs
new file mode 100644
index 00000000000000..05df9c5321bff3
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs
@@ -0,0 +1,2552 @@
+// 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.LoongArch64
+{
+    /// <summary>
+    /// This class provides access to the LSX-128bits hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class LA_LSX : LA64Base
+    {
+        internal LA_LSX() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// int8x16_t vadd_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x2_t vadd_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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>
+        /// int8x16_t vsub_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int64x2_t vsub_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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>
+        /// int8x16_t vmul_b_s8 (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 TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMULW Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int64x2_t vmul_d_s64 (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 TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: TODO 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_f32 (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_f64 (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 vdiv_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint32x4_t vdiv_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) => Divide(left, right);
+
+        /// <summary>
+        /// int64x2_t vdiv_d_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// float32x4_t vfmadd_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) => FusedMultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// float64x2_t vfmadd_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) => FusedMultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int8x16_t vmadd_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int8x16_t TODO_s8 (int8x16_t a, uint8x16_t b)
+        ///   LSX: TODO Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<byte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, int8x16_t b)
+        ///   LSX: TODO Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<sbyte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x8_t TODO_s16 (int16x8_t a, uint16x8_t b)
+        ///   LSX: TODO Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<ushort> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint16x8_t TODO_u16 (uint16x8_t a, int16x8_t b)
+        ///   LSX: TODO Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<short> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int32x4_t TODO_s32 (int32x4_t a, uint32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, int32x4_t b)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x2_t TODO_s64 (int64x2_t a, uint64x2_t b)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<ulong> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x2_t TODO_u64 (uint64x2_t a, int64x2_t b)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<long> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int8x16_t vsadd_b_s8 (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_s16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x2_t vsadd_d_s64 (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_u8 (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_u16 (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_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsadd_du_u64 (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>
+        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> HorizontalAdd(Vector128<sbyte> left, Vector128<sbyte> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> HorizontalAdd(Vector128<byte> left, Vector128<byte> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// int16x8_t vadd_h_s16 (int16x8_t a, int16x8_t b)
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> HorizontalAdd(Vector128<ushort> left, Vector128<ushort> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// int32x4_t vadd_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> HorizontalAdd(Vector128<uint> left, Vector128<uint> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// int64x2_t vadd_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> HorizontalAdd(Vector128<long> left, Vector128<long> right) => HorizontalAdd(left, right);
+
+        /// <summary>
+        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> HorizontalAdd(Vector128<ulong> left, Vector128<ulong> right) => HorizontalAdd(left, right);
+
+        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static sbyte HorizontalSum(Vector128<sbyte> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static byte HorizontalSum(Vector128<byte> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static short HorizontalSum(Vector128<short> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static ushort HorizontalSum(Vector128<ushort> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static int HorizontalSum(Vector128<int> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static uint HorizontalSum(Vector128<uint> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static long HorizontalSum(Vector128<long> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static ulong HorizontalSum(Vector128<ulong> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_float_elements witin value.
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static float HorizontalSum(Vector128<float> value) => HorizontalSum(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_double_elements witin value.
+        ///   LSX: Vector128.ToScalar
+        /// </summary>
+        public static double HorizontalSum(Vector128<double> value) => HorizontalSum(value);
+
+        /// <summary>
+        /// int8x16_t vmsub_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: TODO 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_s16 (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 TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmaddwev_h_b_s8 (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_u8 (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_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
+        ///   LSX: VMADDWEV.W.H Vd.4S, 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_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
+        ///   LSX: VMADDWEV.W.HU Vd.4S, 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_s32 (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_u32 (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_s8 (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_u8 (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_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADDWOD.W.H Vd.4S, 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_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADDWOD.W.HU Vd.4S, 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_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// </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_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x16_t vseq_b_s8 (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_u8 (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>
+        /// uint16x8_t vseq_h_s16 (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_u16 (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>
+        /// uint32x4_t vseq_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vseq_w_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vseq_d_s64 (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_u64 (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>
+        /// uint32x4_t vfcmp_ceq_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CEQ.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vfcmp_ceq_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vslt_b_s8 (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_s8 (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_s16 (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_s16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_wu_s32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_d_s64 (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_s64 (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>
+        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsle_b_s8 (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>
+        /// uint8x16_t vsle_bu_u8 (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_h_s16 (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>
+        /// uint16x8_t vsle_hu_u16 (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_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_d_s64 (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>
+        /// uint64x2_t vsle_du_u64 (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>
+        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsle_b_s8 (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>
+        /// uint8x16_t vsle_bu_u8 (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_h_s16 (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>
+        /// uint16x8_t vsle_hu_u16 (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_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_d_s64 (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>
+        /// uint64x2_t vsle_du_u64 (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>
+        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint8x16_t vslt_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_d_s64 (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_u64 (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>
+        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// int8x16_t vmax_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMAX.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) => Max(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmax_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMAX.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) => Max(left, right);
+
+        /// <summary>
+        /// int64x2_t vmax_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VMAX.D Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right) => Max(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmax_du_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMAX.DU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmax_s_f32 (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_f64 (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>
+        /// int8x16_t vmin_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMIN.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) => Min(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmin_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMIN.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) => Min(left, right);
+
+        /// <summary>
+        /// int64x2_t vmin_d_s64 (int64x2_t a, int64x2_t b)
+        ///   LSX: VMIN.D Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right) => Min(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmin_du_u64 (uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMIN.DU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmin_s_f32 (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_f64 (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>
+        /// int8x16_t vbitsel_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VABSD.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint32x4_t vabsd_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VABSD.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int64x2_t vabsd_d_s64 (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_u64 (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_f32 (float32x4_t a, float32x4_t b)
+        ///   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_f64 (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_s8 (int8_t const * ptr)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint8x16_t vld_u8 (uint8_t const * ptr)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int16x8_t vld_s16 (int16_t const * ptr)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint16x8_t vld_s16 (uint16_t const * ptr)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int32x4_t vld_s32 (int32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint32x4_t vld_s32 (uint32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address) => LoadVector128(address);
+
+        /// <summary>
+        /// int64x2_t vld_s64 (int64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address) => LoadVector128(address);
+
+        /// <summary>
+        /// uint64x2_t vld_u64 (uint64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address) => LoadVector128(address);
+
+        /// <summary>
+        /// float32x4_t vld_f32 (float32_t const * ptr)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address) => LoadVector128(address);
+
+        /// <summary>
+        /// float64x2_t vld_f64 (float64_t const * ptr)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address) => LoadVector128(address);
+
+        /// <summary>
+        /// float32x4_t vfrecip_s_f32 (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_f64 (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_f32 (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_f64 (float64x2_t a)
+        ///   LSX: VFRSQRT.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> ReciprocalSqrt(Vector128<double> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// void vst_s8 (int8_t * ptr, int8x16_t val)
+        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_u8 (uint8_t * ptr, uint8x16_t val)
+        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(byte* address, Vector128<byte> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_s16 (int16_t * ptr, int16x8_t val)
+        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(short* address, Vector128<short> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_u16 (uint16_t * ptr, uint16x8_t val)
+        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ushort* address, Vector128<ushort> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_s32 (int32_t * ptr, int32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(int* address, Vector128<int> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_u32 (uint32_t * ptr, uint32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(uint* address, Vector128<uint> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_s64 (int64_t * ptr, int64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(long* address, Vector128<long> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_u64 (uint64_t * ptr, uint64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(ulong* address, Vector128<ulong> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_f32 (float32_t * ptr, float32x4_t val)
+        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(float* address, Vector128<float> source) => Store(address, source);
+
+        /// <summary>
+        /// void vst_f64 (float64_t * ptr, float64x2_t val)
+        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// </summary>
+        public static unsafe void Store(double* address, Vector128<double> source) => Store(address, source);
+
+        /// <summary>
+        /// int8x16_t vneg_b_s8 (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_s16 (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_s32 (int32x4_t a)
+        ///   LSX: VNEG.W Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> Negate(Vector128<int> value) => Negate(value);
+
+        /// <summary>
+        /// int64x2_t vneg_d_s64 (int64x2_t a)
+        ///   LSX: VNEG.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> Negate(Vector128<long> value) => Negate(value);
+
+        /// <summary>
+        /// float32x4_t TODO_f32 (float32x4_t a)
+        ///   LSX: TODO Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Negate(Vector128<float> value) => Negate(value);
+
+        /// <summary>
+        /// float64x2_t TODO_f64 (float64x2_t a)
+        ///   LSX: TODO Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Negate(Vector128<double> value) => Negate(value);
+
+        /// <summary>
+        /// float32x4_t vfmsub_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right) => FusedMultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// float64x2_t vfmsub_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right) => FusedMultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmulwod_h_b_s8 (int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmulwod_h_bu_u8 (uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int32x4_t vmulwod_w_h_s16 (int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningUpper(Vector128<short> left, Vector128<short> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmulwod_w_hu_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMULWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningUpper(Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int64x2_t vmulwod_d_w_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<long> MultiplyWideningUpper(Vector128<int> left, Vector128<int> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmulwod_d_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpper(Vector128<uint> left, Vector128<uint> right) => MultiplyWideningUpper(left, right);
+
+        /// <summary>
+        /// int8x16_t vssub_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VSSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint32x4_t vssub_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSSUB.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int64x2_t vssub_d_s64 (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_u64 (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 vavg_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x4_t a, int32x4_t b)
+        ///   LSX: VAVG.W Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right) => Average(left, right);
+
+        /// <summary>
+        /// uint32x4_t vavg_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVG.WU Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right) => Average(left, right);
+
+        /// <summary>
+        /// int64x2_t vavg_d_s64 (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_u64 (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>
+        /// int16x8_t vext2xv_h_b_s8 (int8x16_t a)
+        ///   LSX: VEXT2XV.H.B Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
+
+        ///// <summary>
+        ///// int32x4_t vext2xv_w_b_s8 (int8x16_t a)
+        /////   LSX: VEXT2XV.W.B Vd.4W, Vj.16B
+        ///// </summary>
+        //public static Vector128<int> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
+
+        ///// <summary>
+        ///// int64x2_t vext2xv_d_b_s8 (int8x16_t a)
+        /////   LSX: VEXT2XV.D.B Vd.2D, Vj.16B
+        ///// </summary>
+        //public static Vector128<long> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
+
+        /// <summary>
+        /// int32x4_t vext2xv_w_h_s16 (int16x8_t a)
+        ///   LSX: VEXT2XV.W.H Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningLower(Vector128<short> value) => SignExtendWideningLower(value);
+
+        ///// <summary>
+        ///// int64x2_t vext2xv_d_h_s16 (int16x8_t a)
+        /////   LSX: VEXT2XV.D.H Vd.2D, Vj.8H
+        ///// </summary>
+        //public static Vector128<long> SignExtendWideningLower(Vector128<short> value) => SignExtendWideningLower(value);
+
+        /// <summary>
+        /// int64x2_t vext2xv_d_w_s32 (int32x4_t a)
+        ///   LSX: VEXT2XV.D.W Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> SignExtendWideningLower(Vector128<int> value) => SignExtendWideningLower(value);
+
+        /// <summary>
+        /// uint16x8_t vext2xv_hu_bu_u8 (uint8x16_t a)
+        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
+
+        ///// <summary>
+        ///// uint32x4_t vext2xv_wu_bu_u8 (uint8x16_t a)
+        /////   LSX: VEXT2XV.WU.BU Vd.4W, Vj.16B
+        ///// </summary>
+        //public static Vector128<uint> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
+
+        ///// <summary>
+        ///// uint64x2_t vext2xv_du_bu_u8 (uint8x16_t a)
+        /////   LSX: VEXT2XV.DU.BU Vd.2D, Vj.16B
+        ///// </summary>
+        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
+
+        /// <summary>
+        /// uint32x4_t vext2xv_wu_hu_u16 (uint16x8_t a)
+        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningLower(Vector128<ushort> value) => ZeroExtendWideningLower(value);
+
+        ///// <summary>
+        ///// uint64x2_t vext2xv_du_hu_u16 (uint16x8_t a)
+        /////   LSX: VEXT2XV.DU.HU Vd.2D, Vj.8H
+        ///// </summary>
+        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<ushort> value) => ZeroExtendWideningLower(value);
+
+        /// <summary>
+        /// uint64x2_t vext2xv_du_wu_u32 (uint32x4_t a)
+        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector128<uint> value) => ZeroExtendWideningLower(value);
+
+        /// <summary>
+        /// int16x8_t vexth_h_b_s8 (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_s16 (int16x8_t a)
+        ///   LSX: VEXTH.W.H Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int64x2_t vexth_d_w_s32 (int32x4_t a)
+        ///   LSX: VEXTH.D.W Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint16x8_t vexth_HU_BU_u8 (uint8x16_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_u8 (uint8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int8x16_t vand_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x16_t vor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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>
+        /// int8x16_t vxor_v_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (int8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint8x16_t vslli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// int16x8_t vslli_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint16x8_t vslli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint32x4_t vslli_w_s32 (uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint32x4_t vslli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// int64x2_t vslli_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint64x2_t vslli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) => ShiftLeftLogical(value, count);
+
+        /// <summary>
+        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) => ShiftRightLogical(value, count);
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) => ShiftRightLogicalRounded(value, count);
+
+        /// <summary>
+        /// int8x16_t vsrai_b_s8 (int8x16_t a, const int n)
+        ///   LSX: VSRAI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int16x8_t vsrai_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSRAI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int32x4_t vsrai_w_s32 (int32x4_t a, const int n)
+        ///   LSX: VSRAI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int64x2_t vsrai_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSRAI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) => ShiftRightArithmetic(value, count);
+
+        /// <summary>
+        /// int8x16_t vsrari_b_s8 (int8x16_t a, const int n)
+        ///   LSX: VSRARI.B Vd.16B, Vj.16B, #n
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int16x8_t vsrari_h_s16 (int16x8_t a, const int n)
+        ///   LSX: VSRARI.H Vd.8H, Vj.8H, #n
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int32x4_t vsrari_w_s32 (int32x4_t a, const int n)
+        ///   LSX: VSRARI.W Vd.4S, Vj.4S, #n
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int64x2_t vsrari_d_s64 (int64x2_t a, const int n)
+        ///   LSX: VSRARI.D Vd.2D, Vj.2D, #n
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) => ShiftRightArithmeticRounded(value, count);
+
+        /// <summary>
+        /// int8x16_t vadda_b_s8 (int8x16_t a)
+        ///   LSX: VADDA.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x8_t vadda_h_s16 (int16x8_t a)
+        ///   LSX: VADDA.H Vd.8H, Vj.8H, 0
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x4_t vadda_w_s32 (int32x4_t a)
+        ///   LSX: VADDA.W Vd.4S, Vj.4S, 0
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) => Abs(value);
+
+        /// <summary>
+        /// int64x2_t vdda_d_s64 (int64x2_t a)
+        ///   LSX: VADDA.D Vd.2D, Vj.2D, 0
+        /// </summary>
+        public static Vector128<ulong> Abs(Vector128<long> value) => Abs(value);
+
+        /// <summary>
+        /// float32x4_t vbitclri_w_f32 (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_f64 (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 vfsqrt_s_f32 (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_f64 (float64x2_t a)
+        ///   LSX: VFSQRT.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Sqrt(Vector128<double> value) => Sqrt(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrm_s_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_f32 (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_f64 (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_s8 (int8_t a, int8x16_t v, const int imm)
+        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint8x16_t vinsgr2vr_b_u8 (uint8_t a, uint8x16_t v, const int imm)
+        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// </summary>
+        public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int16x8_t vinsgr2vr_h_s16 (int16_t a, int16x8_t v, const int imm)
+        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector128<short> Insert(Vector128<short> vector, byte index, short data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint16x8_t vinsgr2vr_h_u16 (uint16_t a, uint16x8_t v, const int imm)
+        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// </summary>
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int32x4_t vinsgr2vr_w_s32 (int32_t a, int32x4_t v, const int imm)
+        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector128<int> Insert(Vector128<int> vector, byte index, int data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint32x4_t vinsgr2vr_w_u32 (uint32_t a, uint32x4_t v, const int imm)
+        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// </summary>
+        public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int64x2_t vinsgr2vr_d_s64 (int64_t a, int64x2_t v, const int imm)
+        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector128<long> Insert(Vector128<long> vector, byte index, long data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// uint64x2_t vinsgr2vr_d_u64 (uint64_t a, uint64x2_t v, const int imm)
+        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// </summary>
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// float32x4_t xvinsve0_w_f32 (float32_t a, float32x4_t v, const int imm)
+        ///   LSX: XVINSVE0.W Vd.S[imm], Vj.S[0], imm
+        /// </summary>
+        public static Vector128<float> Insert(Vector128<float> vector, byte index, float data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// float64x2_t xvinsve0_d_f64 (float64_t a, float64x2_t v, const int imm)
+        ///   LSX: XVINSVE0.D Vd.D[imm], Vj.D[0], imm
+        /// </summary>
+        public static Vector128<double> Insert(Vector128<double> vector, byte index, double data) => Insert(vector, index, data);
+
+        /// <summary>
+        /// int8x16_t vreplgr2vr_b_s8 (int8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<sbyte> DuplicateToVector128(sbyte value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint8x16_t vreplgr2vr_b_u8 (uint8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<byte> DuplicateToVector128(byte value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int16x8_t vreplgr2vr_h_s16 (int16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<short> DuplicateToVector128(short value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint16x8_t vreplgr2vr_h_u16 (uint16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<ushort> DuplicateToVector128(ushort value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int32x4_t vreplgr2vr_w_s32 (int32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// </summary>
+        public static Vector128<int> DuplicateToVector128(int value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint32x4_t vreplgr2vr_w_u32 (uint32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// </summary>
+        public static Vector128<uint> DuplicateToVector128(uint value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int64x2_t vreplgr2vr_d_s64 (int64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<long> DuplicateToVector128(long value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint64x2_t vreplgr2vr_d_u64 (uint64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<ulong> DuplicateToVector128(ulong value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// float32x4_t xvreplve0_w_f32 (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_f64 (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_f32_s32 (int32x4_t a)
+        ///   LSX: VFFINT.S.W Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<int> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float32x4_t vffint_s_wu_f32_u32 (uint32x4_t a)
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<uint> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float64x2_t vffint_d_l_f64_s64 (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_f64_u64 (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_u8 (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_u16 (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_u8 (uint8x16_t value)
+        ///   LSX: VSETNEZ.V cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector128<byte> value) => HasElementsNotZero(value);
+
+        /// <summary>
+        /// bool vseteqz_v_u8 (uint8x16_t value)
+        ///   LSX: VSETEQZ.V cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector128<byte> value) => AllElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_b_s8 (int8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<sbyte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_b_u8 (uint8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<byte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_h_s16 (int16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<short> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_h_u16 (uint16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ushort> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w_s32 (int32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<int> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w_u32 (uint32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<uint> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w_s64 (int64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<long> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w_u64 (uint64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ulong> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_b_s8 (int8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<sbyte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_b_u8 (uint8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<byte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_h_s16 (int16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<short> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_h_u16 (uint16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ushort> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w_s32 (int32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<int> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w_u32 (uint32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<uint> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w_s64 (int64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<long> value) => HasElementsIsZero(value);
+        /// <summary>
+        /// bool vsetanyeqz_w_u64 (uint64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ulong> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// ulong vsrlni_b_h_16 (int16x8_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<short> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// ulong vsrlni_b_h_u16 (uint16x8_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ushort> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// ulong vsrlni_h_w_s32 (int32x4_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<int> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// ulong vsrlni_h_w_u32 (uint32x4_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<uint> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// ulong vsrlni_w_d_s64 (int64x2_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<long> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// ulong vsrlni_w_d_u64 (uint64x2_t value, shift)
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        ///   LSX: Vd Scalar to uint64.
+        /// </summary>
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ulong> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+
+        /// <summary>
+        /// uint8x16 vsrlni_b_h_u16 (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 vsrlni_h_w_s32 (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 vsrlni_h_w_u32 (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 vsrlni_w_d_s64 (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 vsrlni_w_d_u64 (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>
+        /// int8x16_t vpcnt_b_s8 (int8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x16_t vpcnt_b_u8 (uint8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<byte> PopCount(Vector128<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x8_t vpcnt_h_s16 (int16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<short> PopCount(Vector128<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x8_t vpcnt_h_u16 (uint16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<ushort> PopCount(Vector128<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x4_t vpcnt_w_s32 (int32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<int> PopCount(Vector128<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x4_t vpcnt_w_u32 (uint32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<uint> PopCount(Vector128<uint> value) => PopCount(value);
+
+        /// <summary>
+        /// int64x2_t vpcnt_d_s64 (int64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<long> PopCount(Vector128<long> value) => PopCount(value);
+
+        /// <summary>
+        /// uint64x2_t vpcnt_d_u64 (uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) => PopCount(value);
+
+        ////TODO: other liking vsrani .......
+    }
+}
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..3a66c867842bb0 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,844 @@ internal Arm64() { }
         }
     }
 }
+namespace System.Runtime.Intrinsics.LoongArch64
+{
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class LA64Base
+    {
+        internal LA64Base() { }
+        public static bool IsSupported { get { throw null; } }
+
+        public static int LeadingSignCount(int value) { throw null; }
+        public static int LeadingSignCount(long 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 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 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; }
+    }
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class LA_LSX : System.Runtime.Intrinsics.LoongArch64.LA64Base
+    {
+        internal LA_LSX() { }
+        public static new bool IsSupported { get { 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.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> 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> 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<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<double> addend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<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<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<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> 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<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddSaturate(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector128<sbyte> 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<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AddSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddSaturate(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<long> 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> 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<float> CompareEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> CompareEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> CompareLessThan(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> CompareLessThan(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<uint> CompareLessThan(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> CompareLessThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { 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<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> 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<float> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<sbyte> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<double> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<ulong> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> 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<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<uint> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<int> Max(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> Max(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<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<double> Max(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> Min(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> Min(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<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<double> Min(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<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<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<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<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<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<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<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<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<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<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<float> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<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 System.Runtime.Intrinsics.Vector128<double> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadVector128(byte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadVector128(double* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadVector128(short* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadVector128(int* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> LoadVector128(long* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<sbyte> LoadVector128(sbyte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> LoadVector128(float* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ushort> LoadVector128(ushort* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> LoadVector128(uint* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> LoadVector128(ulong* address) { throw null; }
+        public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector128<byte> source) { }
+        public unsafe static void Store(double* address, System.Runtime.Intrinsics.Vector128<double> source) { }
+        public unsafe static void Store(short* address, System.Runtime.Intrinsics.Vector128<short> source) { }
+        public unsafe static void Store(int* address, System.Runtime.Intrinsics.Vector128<int> source) { }
+        public unsafe static void Store(long* address, System.Runtime.Intrinsics.Vector128<long> source) { }
+        public unsafe static void Store(sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> source) { }
+        public unsafe static void Store(float* address, System.Runtime.Intrinsics.Vector128<float> source) { }
+        public unsafe static void Store(ushort* address, System.Runtime.Intrinsics.Vector128<ushort> source) { }
+        public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector128<uint> source) { }
+        public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector128<ulong> source) { }
+        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.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> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<int> SubtractSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<byte> Average(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<sbyte> Average(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<short> Average(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<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<short> SignExtendWideningUpper(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<long> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<int> 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<uint> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> 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<byte> And(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<short> And(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<long> And(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { 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<float> And(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<uint> And(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<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<int> AndNot(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> AndNot(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<uint> AndNot(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<double> AndNot(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<byte> Or(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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.Vector128<short> Or(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<long> Or(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> 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<float> Or(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<uint> Or(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<byte> Xor(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<short> Xor(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<long> Xor(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> 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<float> Xor(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<uint> Xor(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.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<double> Sqrt(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Sqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.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, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, sbyte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> vector, byte index, byte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> vector, byte index, short data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> vector, byte index, ushort data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> vector, byte index, int data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> vector, byte index, uint data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> vector, byte index, long data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> vector, byte index, ulong data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> vector, byte index, float data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Insert(System.Runtime.Intrinsics.Vector128<double> vector, byte index, double data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateToVector128(sbyte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateToVector128(byte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> DuplicateToVector128(short value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateToVector128(ushort value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DuplicateToVector128(int value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateToVector128(uint value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> DuplicateToVector128(long value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateToVector128(ulong value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> DuplicateToVector128(float value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> DuplicateToVector128(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 System.Runtime.Intrinsics.Vector128<sbyte> HorizontalAdd(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> HorizontalAdd(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> HorizontalAdd(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> HorizontalAdd(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> HorizontalAdd(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> HorizontalAdd(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> HorizontalAdd(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> HorizontalAdd(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static sbyte HorizontalSum(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static byte HorizontalSum(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static short HorizontalSum(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static ushort HorizontalSum(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static int HorizontalSum(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static uint HorizontalSum(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static long HorizontalSum(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static ulong HorizontalSum(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static float HorizontalSum(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static double HorizontalSum(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<uint> 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 ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<ushort> value, byte shift) { throw null; }
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<int> value, byte shift) { throw null; }
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<uint> value, byte shift) { throw null; }
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<long> value, byte shift) { throw null; }
+        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<ulong> value, byte shift) { 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.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; }
+    }
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class LA_LASX : System.Runtime.Intrinsics.LoongArch64.LA_LSX
+    {
+        internal LA_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> 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> 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> 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<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<float> addend, System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<double> addend, System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<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<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<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<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AddSaturate(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector256<byte> 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<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddSaturate(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector256<sbyte> 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<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AddSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddSaturate(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> 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<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<int> CompareLessThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> CompareLessThan(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<uint> CompareLessThan(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<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<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { 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<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> 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<float> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<float> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<uint> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<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<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<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<uint> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<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<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<int> Max(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> Max(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<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<double> Max(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> Min(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> Min(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<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<double> Min(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<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<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<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<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<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<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<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<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<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<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<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<float> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<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<double> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<byte> LoadVector256(byte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<double> LoadVector256(double* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<short> LoadVector256(short* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<int> LoadVector256(int* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<long> LoadVector256(long* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<sbyte> LoadVector256(sbyte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<float> LoadVector256(float* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ushort> LoadVector256(ushort* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<uint> LoadVector256(uint* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> LoadVector256(ulong* address) { throw null; }
+        public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector256<byte> source) { }
+        public unsafe static void Store(double* address, System.Runtime.Intrinsics.Vector256<double> source) { }
+        public unsafe static void Store(short* address, System.Runtime.Intrinsics.Vector256<short> source) { }
+        public unsafe static void Store(int* address, System.Runtime.Intrinsics.Vector256<int> source) { }
+        public unsafe static void Store(long* address, System.Runtime.Intrinsics.Vector256<long> source) { }
+        public unsafe static void Store(sbyte* address, System.Runtime.Intrinsics.Vector256<sbyte> source) { }
+        public unsafe static void Store(float* address, System.Runtime.Intrinsics.Vector256<float> source) { }
+        public unsafe static void Store(ushort* address, System.Runtime.Intrinsics.Vector256<ushort> source) { }
+        public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector256<uint> source) { }
+        public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector256<ulong> source) { }
+        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<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> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<float> minuend, System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<double> minuend, System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<int> SubtractSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<byte> Average(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Average(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Average(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<short> Average(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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<int> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<uint> value) { 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<double> And(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> And(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> And(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        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<sbyte> And(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<ushort> And(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> 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<ulong> And(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> 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<int> AndNot(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> AndNot(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<uint> AndNot(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<double> AndNot(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> AndNot(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Or(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<short> Or(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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<long> Or(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> 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<float> Or(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<uint> Or(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<byte> Xor(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<short> Xor(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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<long> Xor(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> 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<float> Xor(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<uint> Xor(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { 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<double> Sqrt(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Sqrt(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public 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<sbyte> Insert(System.Runtime.Intrinsics.Vector256<sbyte> vector, byte index, sbyte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Insert(System.Runtime.Intrinsics.Vector256<byte> vector, byte index, byte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Insert(System.Runtime.Intrinsics.Vector256<short> vector, byte index, short data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Insert(System.Runtime.Intrinsics.Vector256<ushort> vector, byte index, ushort data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Insert(System.Runtime.Intrinsics.Vector256<int> vector, byte index, int data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Insert(System.Runtime.Intrinsics.Vector256<uint> vector, byte index, uint data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Insert(System.Runtime.Intrinsics.Vector256<long> vector, byte index, long data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Insert(System.Runtime.Intrinsics.Vector256<ulong> vector, byte index, ulong data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Insert(System.Runtime.Intrinsics.Vector256<float> vector, byte index, float data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Insert(System.Runtime.Intrinsics.Vector256<double> vector, byte index, double data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> DuplicateToVector256(sbyte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> DuplicateToVector256(byte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> DuplicateToVector256(short value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> DuplicateToVector256(ushort value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> DuplicateToVector256(int value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> DuplicateToVector256(uint value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> DuplicateToVector256(long value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> DuplicateToVector256(ulong value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> DuplicateToVector256(float value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> DuplicateToVector256(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> 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; }
+    }
+}
 namespace System.Runtime.Intrinsics.X86
 {
     [System.CLSCompliantAttribute(false)]

From 5c601e1154c1a44f7f0b8f8ab4d5eb0e380d066e Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Tue, 7 Nov 2023 11:12:07 +0800
Subject: [PATCH 02/11] Rename LA64Base -> LoongArchBase, LA_LSX -> Lsx,
 LA_LASX -> Lasx. Update the API within the LoongArchBase class.

---
 .../Lasx.PlatformNotSupported.cs}             |   0
 .../LA_LASX.cs => LoongArch/Lasx.cs}          |   6 +-
 .../LoongArchBase.PlatformNotSupported.cs}    |   0
 .../Intrinsics/LoongArch/LoongArchBase.cs     | 198 ++++++++++++++++
 .../Lsx.PlatformNotSupported.cs}              |   0
 .../LA_LSX.cs => LoongArch/Lsx.cs}            |   6 +-
 .../Intrinsics/LoongArch64/LA64Base.cs        | 212 ------------------
 7 files changed, 204 insertions(+), 218 deletions(-)
 rename src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/{LoongArch64/LA_LASX.PlatformNotSupported.cs => LoongArch/Lasx.PlatformNotSupported.cs} (100%)
 rename src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/{LoongArch64/LA_LASX.cs => LoongArch/Lasx.cs} (99%)
 rename src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/{LoongArch64/LA64Base.PlatformNotSupported.cs => LoongArch/LoongArchBase.PlatformNotSupported.cs} (100%)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs
 rename src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/{LoongArch64/LA_LSX.PlatformNotSupported.cs => LoongArch/Lsx.PlatformNotSupported.cs} (100%)
 rename src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/{LoongArch64/LA_LSX.cs => LoongArch/Lsx.cs} (99%)
 delete mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.PlatformNotSupported.cs
similarity index 100%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.PlatformNotSupported.cs
rename to src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.PlatformNotSupported.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs
similarity index 99%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs
rename to src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs
index 84700b834b2122..d062c8a8cef515 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LASX.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs
@@ -3,16 +3,16 @@
 
 using System.Runtime.CompilerServices;
 
-namespace System.Runtime.Intrinsics.LoongArch64
+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 LA_LASX : LA_LSX
+    public abstract class Lasx : Lsx
     {
-        internal LA_LASX() { }
+        internal Lasx() { }
 
         public static new bool IsSupported { get => IsSupported; }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.PlatformNotSupported.cs
similarity index 100%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.PlatformNotSupported.cs
rename to src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.PlatformNotSupported.cs
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..e1947deb6601c1
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs
@@ -0,0 +1,198 @@
+// 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>
+        ///   LA32: MULH.W rd, rj, rk
+        /// </summary>
+        public static long MultiplyHigh(int left, int right) => MultiplyHigh(left, right);
+
+        /// <summary>
+        ///   LA32: MULH.WU rd, rj, rk
+        /// </summary>
+        public static ulong MultiplyHigh(uint left, uint right) => MultiplyHigh(left, right);
+
+        /// <summary>
+        ///   LA32: FSQRT.S fd, fj
+        /// </summary>
+        public static float SquareRoot(float value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA32: FSQRT.D fd, fj
+        /// </summary>
+        public static double SquareRoot(double value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA32: FRECIP.S fd, fj
+        /// </summary>
+        public static float Reciprocal(float value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA32: FRECIP.D fd, fj
+        /// </summary>
+        public static double Reciprocal(double value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA32: FRSQRT.S fd, fj
+        /// </summary>
+        public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        ///   LA32: FRSQRT.D fd, fj
+        /// </summary>
+        public static double ReciprocalSqrt(double value) => ReciprocalSqrt(value);
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.PlatformNotSupported.cs
similarity index 100%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.PlatformNotSupported.cs
rename to src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.PlatformNotSupported.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
similarity index 99%
rename from src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs
rename to src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
index 05df9c5321bff3..437add31f2fb7d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA_LSX.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
@@ -3,16 +3,16 @@
 
 using System.Runtime.CompilerServices;
 
-namespace System.Runtime.Intrinsics.LoongArch64
+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 LA_LSX : LA64Base
+    public abstract class Lsx : LoongArchBase
     {
-        internal LA_LSX() { }
+        internal Lsx() { }
 
         public static new bool IsSupported { get => IsSupported; }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs
deleted file mode 100644
index fbb4a35f4a3ea7..00000000000000
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch64/LA64Base.cs
+++ /dev/null
@@ -1,212 +0,0 @@
-// 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.LoongArch64
-{
-    /// <summary>
-    /// This class provides access to the LA64 base hardware instructions via intrinsics
-    /// </summary>
-    [Intrinsic]
-    [CLSCompliant(false)]
-    public abstract class LA64Base
-    {
-        internal LA64Base() { }
-
-        public static bool IsSupported { get => IsSupported; }
-
-        /// <summary>
-        ///   LA64: CLO.W rd, rj
-        /// </summary>
-        public static int LeadingSignCount(int value) => LeadingSignCount(value);
-
-        /// <summary>
-        ///   LA64: CLO.D rd, rj
-        /// </summary>
-        public static int LeadingSignCount(long 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: 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: FSQRT.S fd, fj
-        /// </summary>
-        public static float SquareRoot(float value) => SquareRoot(value);
-
-        /// <summary>
-        ///   LA64: FSQRT.D fd, fj
-        /// </summary>
-        public static double SquareRoot(double value) => SquareRoot(value);
-
-        /// <summary>
-        ///   LA64: FRECIP.S fd, fj
-        /// </summary>
-        public static float Reciprocal(float value) => Reciprocal(value);
-
-        /// <summary>
-        ///   LA64: FRECIP.D fd, fj
-        /// </summary>
-        public static double Reciprocal(double value) => Reciprocal(value);
-
-        /// <summary>
-        ///   LA64: FRSQRT.S fd, fj
-        /// </summary>
-        public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);
-
-        /// <summary>
-        ///   LA64: FRSQRT.D fd, fj
-        /// </summary>
-        public static double ReciprocalSqrt(double value) => ReciprocalSqrt(value);
-
-#if false
-        // TODO-LA: adding  bstrins, bstrpick, bytepick
-        /// <summary>
-        ///   LA64: BYTEPICK.W rd, rj, sa2
-        /// </summary>
-        public static int SpliceAndCutBits(int left, int right, uint start) => SpliceAndCutBits(left, right, start);
-
-        /// <summary>
-        ///   LA64: BYTEPICK.W rd, rj, sa2
-        /// </summary>
-        public static uint SpliceAndCutBits(uint left, uint right, uint start) => SpliceAndCutBits(left, right, start);
-
-        /// <summary>
-        ///   LA64: BYTEPICK.D rd, rj, sa3
-        /// </summary>
-        public static long SpliceAndCutBits(long left, long right, uint start) => SpliceAndCutBits(left, right, start);
-
-        /// <summary>
-        ///   LA64: BYTEPICK.D rd, rj, sa3
-        /// </summary>
-        public static ulong SpliceAndCutBits(ulong left, ulong right, uint start) => SpliceAndCutBits(left, right, start);
-
-        /// <summary>
-        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
-        /// </summary>
-        public static int ReplaceBits(int left, int right, uint end, uint start) => ReplaceBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
-        /// </summary>
-        public static uint ReplaceBits(uint left, uint right, uint end, uint start) => ReplaceBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static long ReplaceBits(long left, long right, uint end, uint start) => ReplaceBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static ulong ReplaceBits(ulong left, ulong right, uint end, uint start) => ReplaceBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
-        /// </summary>
-        public static int CutBits(int left, int right, uint end, uint start) => CutBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
-        /// </summary>
-        public static uint CutBits(uint left, uint right, uint end, uint start) => CutBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static long CutBits(long left, long right, uint end, uint start) => CutBits(left, right, end, start);
-
-        /// <summary>
-        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static ulong CutBits(ulong left, ulong right, uint end, uint start) => CutBits(left, right, end, start);
-#endif
-    }
-}

From 6e3a9e7c974f9e59410696167866d05002217e06 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Fri, 10 Nov 2023 14:44:09 +0800
Subject: [PATCH 03/11] Lsx-PartA: add some APIs for Lsx.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      |  50 +++
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 286 ++++++++++++++++--
 2 files changed, 319 insertions(+), 17 deletions(-)

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
index d062c8a8cef515..cb59c53d164c3d 100644
--- 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
@@ -2265,5 +2265,55 @@ internal Lasx() { }
         ///   LASX: XVPCNT_D Xd, Xj
         /// </summary>
         public static Vector256<ulong> PopCount(Vector256<ulong> value) => PopCount(value);
+
+        /// <summary>
+        ///  uint8x32_t xvrepl128vei_u8(uint8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> VectorElementReplicate(Vector256<byte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int8x32_t xvrepl128vei_s8(int8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> VectorElementReplicate(Vector256<sbyte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int16x16_t xvrepl128vei_s16(int16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<short> VectorElementReplicate(Vector256<short> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint16x16_t xvrepl128vei_u16(uint16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPLVEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<ushort> VectorElementReplicate(Vector256<ushort> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int32x8_t xvrepl128vei_s32(int32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<int> VectorElementReplicate(Vector256<int> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint32x8_t xvrepl128vei_u32(uint32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<uint> VectorElementReplicate(Vector256<uint> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int64x4_t xvrepl128vei_s64(int64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<long> VectorElementReplicate(Vector256<long> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint64x4_t xvrepl128vei_u64(uint64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<ulong> VectorElementReplicate(Vector256<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        // TODO:----------------------------------
     }
 }
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
index 437add31f2fb7d..00d5586ffb0978 100644
--- 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
@@ -1534,17 +1534,11 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<ushort> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
 
-        ///// <summary>
-        ///// uint32x4_t vext2xv_wu_bu_u8 (uint8x16_t a)
-        /////   LSX: VEXT2XV.WU.BU Vd.4W, Vj.16B
-        ///// </summary>
-        //public static Vector128<uint> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
-
-        ///// <summary>
-        ///// uint64x2_t vext2xv_du_bu_u8 (uint8x16_t a)
-        /////   LSX: VEXT2XV.DU.BU Vd.2D, Vj.16B
-        ///// </summary>
-        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
+        /// <summary>
+        /// int16x8_t vext2xv_hu_bu_u8 (int8x16_t a)
+        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> ZeroExtendWideningLower(Vector128<sbyte> value) => ZeroExtendWideningLower(value);
 
         /// <summary>
         /// uint32x4_t vext2xv_wu_hu_u16 (uint16x8_t a)
@@ -1552,11 +1546,11 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<uint> ZeroExtendWideningLower(Vector128<ushort> value) => ZeroExtendWideningLower(value);
 
-        ///// <summary>
-        ///// uint64x2_t vext2xv_du_hu_u16 (uint16x8_t a)
-        /////   LSX: VEXT2XV.DU.HU Vd.2D, Vj.8H
-        ///// </summary>
-        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<ushort> value) => ZeroExtendWideningLower(value);
+        /// <summary>
+        /// int32x4_t vext2xv_wu_hu_u16 (int16x8_t a)
+        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningLower(Vector128<short> value) => ZeroExtendWideningLower(value);
 
         /// <summary>
         /// uint64x2_t vext2xv_du_wu_u32 (uint32x4_t a)
@@ -1564,6 +1558,12 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<ulong> ZeroExtendWideningLower(Vector128<uint> value) => ZeroExtendWideningLower(value);
 
+        /// <summary>
+        /// int64x2_t vext2xv_du_wu_u32 (int32x4_t a)
+        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningLower(Vector128<int> value) => ZeroExtendWideningLower(value);
+
         /// <summary>
         /// int16x8_t vexth_h_b_s8 (int8x16_t a)
         ///   LSX: VEXTH.H.B Vd.8H, Vj.16B
@@ -1798,6 +1798,126 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) => Or(left, right);
 
+        /// <summary>
+        /// int8x16_t vor_v_s8 (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 vor_v_u8 (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 vor_v_s16 (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 vor_v_u16 (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 vor_v_s32 (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 vor_v_u32 (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 vor_v_s64 (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 vor_v_u64 (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 vor_v_f32 (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 vor_v_f64 (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>
+        /// int8x16_t vor_v_s8 (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 vor_v_u8 (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_s16 (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_u16 (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 vor_v_s32 (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 vor_v_u32 (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 vor_v_s64 (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 vor_v_u64 (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 vor_v_f32 (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 vor_v_f64 (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>
         /// int8x16_t vxor_v_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
@@ -2547,6 +2667,138 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<ulong> PopCount(Vector128<ulong> value) => PopCount(value);
 
-        ////TODO: other liking vsrani .......
+        /// <summary>
+        ///  uint8x16_t vshuffle_u8(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> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+
+        /// <summary>
+        ///  int8x16_t vshuffle_s8(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> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+
+        /// <summary>
+        ///  uint8x16_t vshuffle_u8(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  int8x16_t vshuffle_s8(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  int16x8_t vshuffle_s16(int16x8_t vec, int16x8_t idx)
+        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorShuffle(Vector128<short> vector, Vector128<short> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+
+        /// <summary>
+        ///  uint16x8_t vshuffle_u16(uint16x8_t vec, uint16x8_t idx)
+        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector, Vector128<ushort> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+
+        /// <summary>
+        ///  int16x8_t vshuffle_s16(int16x8_t vec0, int16x8_t vec1, int16x8_t idx)
+        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  uint16x8_t vshuffle_u16(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  int32x4_t vshuffle_s32(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
+        ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  uint32x4_t vshuffle_u32(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
+        ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  int64x2_t vshuffle_s64(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
+        ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  uint64x2_t vshuffle_u64(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
+        ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+
+        /// <summary>
+        ///  uint8x16_t vreplve_u8(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_s8(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_s16(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_u16(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_s32(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_u32(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_s64(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_u32(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);
+
+
+
+        // TODO: other liking vsrani .......
+        // TODO:----------------------------------
+
     }
 }

From 1e7203a4acd6dca09ef331b4c28301b492cc9aae Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Thu, 16 Nov 2023 15:56:25 +0800
Subject: [PATCH 04/11] Lsx-PartB, Lasx-PartA: add some bitwise ops,
 MultiplyHight, Mod,     Sign-Zero-extend and MultiplyWiden

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 860 ++++++++++++++++--
 .../Intrinsics/LoongArch/LoongArchBase.cs     |   1 +
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 769 +++++++++++++---
 3 files changed, 1455 insertions(+), 175 deletions(-)

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
index cb59c53d164c3d..f866911af20d5b 100644
--- 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
@@ -143,8 +143,8 @@ internal Lasx() { }
         public static Vector256<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// uint8x32_t xvmul_b_u8 (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);
 
@@ -155,20 +155,20 @@ internal Lasx() { }
         public static Vector256<short> Multiply(Vector256<short> left, Vector256<short> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// uint16x16_t xvmul_h_u16 (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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMULW Xd.8S, Xj.8S, Xk.8S
+        ///   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 TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// uint32x8_t xvmul_w_u32 (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);
 
@@ -179,8 +179,8 @@ internal Lasx() { }
         public static Vector256<long> Multiply(Vector256<long> left, Vector256<long> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint64x4_t TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// uint64x4_t xvmul_d_u64 (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);
 
@@ -196,6 +196,54 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) => Multiply(left, right);
 
+        /// <summary>
+        /// int8x32_t xvmuh_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_s8 (int8x32_t a, int8x32_t b)
         ///   LASX: XVDIV.B Xd.32B, Xj.32B, Xk.32B
@@ -222,13 +270,13 @@ internal Lasx() { }
 
         /// <summary>
         /// int32x8_t xvdiv_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        ///   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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        ///   LASX: XVDIV.WU Xd.8W, Xj.8W, Xk.8W
         /// </summary>
         public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) => Divide(left, right);
 
@@ -256,6 +304,54 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) => Divide(left, right);
 
+        /// <summary>
+        /// int8x32_t xvmod_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
         ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
@@ -1182,7 +1278,7 @@ internal Lasx() { }
 
         /// <summary>
         /// void xvst_f32 (float32_t * ptr, float32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        ///   LASX: XVST { Xd.8W }, Rj, si12
         /// </summary>
         public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source);
 
@@ -1206,7 +1302,7 @@ internal Lasx() { }
 
         /// <summary>
         /// int32x8_t xvneg_w_s32 (int32x8_t a)
-        ///   LASX: XVNEG.W Xd.8S, Xj.8S
+        ///   LASX: XVNEG.W Xd.8W, Xj.8W
         /// </summary>
         public static Vector256<int> Negate(Vector256<int> value) => Negate(value);
 
@@ -1244,37 +1340,145 @@ internal Lasx() { }
         /// int16x16_t xvmulwod_h_b_s8 (int8x32_t a, int8x32_t b)
         ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> MultiplyWideningUpper(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<short> MultiplyWideningOdd(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmulwod_w_h_s16 (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_s32 (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_s64 (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>
-        /// uint16x16_t xvmulwod_h_bu_u8 (uint8x32_t a, uint8x32_t b)
+        /// int16x16_t xvmulwev_h_b_s8 (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_s16 (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_s32 (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_s64 (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_u8 (uint8x32_t a, uint8x32_t b)
         ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> MultiplyWideningUpper(Vector256<byte> left, Vector256<byte> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<ushort> MultiplyWideningOdd(Vector256<byte> left, Vector256<byte> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// int32x8_t xvmulwod_w_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVMULWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// uint32x8_t xvmulwod_wu_hu_u16 (uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWOD.W.HU Xd.8W, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> MultiplyWideningUpper(Vector256<short> left, Vector256<short> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<uint> MultiplyWideningOdd(Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// uint32x8_t xvmulwod_w_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVMULWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// uint64x4_t xvmulwod_du_wu_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<uint> MultiplyWideningUpper(Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<ulong> MultiplyWideningOdd(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// int64x4_t xvmulwod_d_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// uint128x2_t xvmulwod_qu_du_u64 (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_u8 (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_u16 (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_u32 (uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWEV.D.WU Xd.4D, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> MultiplyWideningUpper(Vector256<int> left, Vector256<int> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// uint64x4_t xvmulwod_d_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// uint128x2_t xvmulwev_qu_du_u64 (uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMULWEV.Q.DU Xd.2Q, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ulong> MultiplyWideningUpper(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningUpper(left, right);
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<ulong> left, Vector256<ulong> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmulwod_h_bu_s8 (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_s16 (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_s32 (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_s64 (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_s8 (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_s16 (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_s32 (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_s64 (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 xvssub_b_s8 (int8x32_t a, int8x32_t b)
@@ -1355,76 +1559,382 @@ internal Lasx() { }
         public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) => Average(left, right);
 
         /// <summary>
-        /// uint32x8_t xvavg_wu_u32 (uint32x8_t a, uint32x8_t b)
+        /// uint32x8_t xvavg_wu_u32(uint32x8_t a, uint32x8_t b)
         ///   LASX: XVAVG.WU Xd.8S, Xj.8S, Xk.8S
         /// </summary>
         public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) => Average(left, right);
 
         /// <summary>
-        /// int64x4_t xvavg_d_s64 (int64x4_t a, int64x4_t b)
+        /// int64x4_t xvavg_d_s64(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_u64 (uint64x4_t a, uint64x4_t b)
+        /// uint64x4_t xvavg_du_u64(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>
-        /// int16x16_t xvexth_h_b_s8 (int8x32_t a)
+        /// int16x16_t xvsllwil_h_b_s8(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_u8(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_s16(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_u16(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_s32(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_u32(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_u8(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_s8(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_u16(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_s16(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_u32(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_s32(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_s64(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_u64(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_s8(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_u8(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_s8(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_u8(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_s8(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_u8(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_s16(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_u16(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_u16(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_u16(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_s32(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_u32(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_u8(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_s8(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_u8(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_s8(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_u8(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_s8(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_u16(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_s16(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_u16(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_s16(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_u32(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_s32(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_s8(int8x32_t a)
         ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
         /// </summary>
-        public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) => SignExtendWideningUpper(value);
+        public static Vector256<short> SignExtendWideningUpperEach128(Vector256<sbyte> value) => SignExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// int32x8_t xvexth_w_h_s16 (int16x16_t a)
-        ///   LASX: XVEXTH.W.H Xd.8S, Xj.16H
+        /// int32x8_t xvexth_w_h_s16(int16x16_t a)
+        ///   LASX: XVEXTH.W.H Xd.8W, Xj.16H
         /// </summary>
-        public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) => SignExtendWideningUpper(value);
+        public static Vector256<int> SignExtendWideningUpperEach128(Vector256<short> value) => SignExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// int64x4_t xvexth_d_w_s32 (int32x8_t a)
-        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8S
+        /// int64x4_t xvexth_d_w_s32(int32x8_t a)
+        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8W
         /// </summary>
-        public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) => SignExtendWideningUpper(value);
+        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<int> value) => SignExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        /// int128x2_t xvexth_d_w_s64(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_s8(int8x32_t a)
         ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
         /// </summary>
-        public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<short> ZeroExtendWideningUpperEach128(Vector256<sbyte> value) => ZeroExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        /// uint16x16_t xvexth_HU_BU_u8(uint8x32_t a)
         ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
         /// </summary>
-        public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<ushort> ZeroExtendWideningUpperEach128(Vector256<byte> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int32x8_t xvexth_WU_HU_s16(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_u16 (uint16x16_t a)
-        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// uint32x8_t xvexth_WU_HU_u16(uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8W, Xj.16H
         /// </summary>
-        public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<uint> ZeroExtendWideningUpperEach128(Vector256<ushort> value) => ZeroExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
-        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        /// int64x4_t xvexth_DU_WU_s32(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
         /// </summary>
-        public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<long> ZeroExtendWideningUpperEach128(Vector256<int> value) => ZeroExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// uint64x4_t xvexth_DU_WU_u32(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
         /// </summary>
-        public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<uint> value) => ZeroExtendWideningUpperEach128(value);
 
         /// <summary>
-        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        /// int128x2_t xvexth_DU_WU_s64(int64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
         /// </summary>
-        public static Vector256<ulong> ZeroExtendWideningUpper(Vector256<uint> value) => ZeroExtendWideningUpper(value);
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<long> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// uint128x2_t xvexth_DU_WU_u64(uint64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<ulong> value) => ZeroExtendWideningUpperEach128(value);
+
+
+        ------------------------
+        ///// <summary>
+        ///// int16x16_t xvexth_h_b_s8 (int8x32_t a)
+        /////   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        ///// </summary>
+        //public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) => SignExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// int32x8_t xvexth_w_h_s16 (int16x16_t a)
+        /////   LASX: XVEXTH.W.H Xd.8S, Xj.16H
+        ///// </summary>
+        //public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) => SignExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// int64x4_t xvexth_d_w_s32 (int32x8_t a)
+        /////   LASX: XVEXTH.D.W Xd.4D, Xj.8S
+        ///// </summary>
+        //public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) => SignExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        /////   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        ///// </summary>
+        //public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) => ZeroExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
+        /////   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        ///// </summary>
+        //public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) => ZeroExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        /////   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        ///// </summary>
+        //public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) => ZeroExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
+        /////   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        ///// </summary>
+        //public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) => ZeroExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        /////   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        ///// </summary>
+        //public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) => ZeroExtendWideningUpper(value);
+
+        ///// <summary>
+        ///// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
+        /////   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        ///// </summary>
+        //public static Vector256<ulong> ZeroExtendWideningUpper(Vector256<uint> value) => ZeroExtendWideningUpper(value);
 
         /// <summary>
         /// int8x32_t xvand_v_s8 (int8x32_t a, int8x32_t b)
@@ -1606,6 +2116,246 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) => Or(left, right);
 
+        /// <summary>
+        /// uint8x32_t xvnori_b_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (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_f64 (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_s8 (int8x32_t a, int8x32_t b)
         ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
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
index e1947deb6601c1..a997d1df54258b 100644
--- 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
@@ -153,6 +153,7 @@ internal LoongArch64() { }
             /// </summary>
             public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);
 
+            // TODO: add crc, ????
         }
 
         /// <summary>
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
index 00d5586ffb0978..04b4de52f33efe 100644
--- 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
@@ -143,8 +143,8 @@ internal Lsx() { }
         public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint8x16_t vmul_b_u8 (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);
 
@@ -155,20 +155,20 @@ internal Lsx() { }
         public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint16x8_t vmul_h_u16 (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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMULW Vd.4S, Vj.4S, Vk.4S
+        ///   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 TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// uint32x4_t vmul_u32 (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);
 
@@ -179,8 +179,8 @@ internal Lsx() { }
         public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint64x2_t vmul_u64 (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);
 
@@ -196,6 +196,54 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
 
+        /// <summary>
+        /// int8x16_t vmuh_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
@@ -222,13 +270,13 @@ internal Lsx() { }
 
         /// <summary>
         /// int32x4_t vdiv_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        ///   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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: VDIV.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
         public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) => Divide(left, right);
 
@@ -256,6 +304,54 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
 
+        /// <summary>
+        /// int8x16_t vmod_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
         ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
@@ -1348,6 +1444,18 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> Negate(Vector128<double> value) => Negate(value);
 
+        /// <summary>
+        /// float64x1_t fneg_d_f64 (float64x1_t a)
+        ///   LSX: FNEG.D Fd, Fj
+        /// </summary>
+        public static Vector64<double> NegateScalar(Vector64<double> value) => NegateScalar(value);
+
+        /// <summary>
+        /// float32_t fneg_s_f32 (float32_t a)
+        ///   LSX: FNEG.S Fd, Fj
+        /// </summary>
+        public static Vector64<float> NegateScalar(Vector64<float> value) => NegateScalar(value);
+
         /// <summary>
         /// float32x4_t vfmsub_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
         ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
@@ -1364,260 +1472,380 @@ internal Lsx() { }
         /// int16x8_t vmulwod_h_b_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> MultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<short> MultiplyWideningOdd(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int32x4_t vmulwod_w_h_s16 (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_s32 (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_s64 (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_s8 (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_s16 (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>
-        /// uint16x8_t vmulwod_h_bu_u8 (uint8x16_t a, uint8x16_t b)
+        /// int64x2_t vmulwev_d_w_s32 (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_s64 (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_u8 (uint8x16_t a, uint8x16_t b)
         ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ushort> MultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<ushort> MultiplyWideningOdd(Vector128<byte> left, Vector128<byte> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// int32x4_t vmulwod_w_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMULWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// uint32x4_t vmulwod_wu_hu_u16 (uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMULWOD.W.HU Vd.4W, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> MultiplyWideningUpper(Vector128<short> left, Vector128<short> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<uint> MultiplyWideningOdd(Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// uint32x4_t vmulwod_w_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMULWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// uint64x2_t vmulwod_du_wu_u32 (uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> MultiplyWideningUpper(Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<ulong> MultiplyWideningOdd(Vector128<uint> left, Vector128<uint> right) => MultiplyWideningOdd(left, right);
 
         /// <summary>
-        /// int64x2_t vmulwod_d_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// uint128x1_t vmulwod_qu_du_u64 (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_u8 (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_u16 (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_u32 (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_u64 (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_s8 (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_s16 (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_s32 (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_s64 (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_s8 (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) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int32x4_t vmulwev_w_hu_s16 (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) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int64x2_t vmulwev_d_wu_s32 (uint32x4_t a, int32x4_t b)
+        ///   LSX: VMULWEV.D.WU.W Vd.2D, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> MultiplyWideningUpper(Vector128<int> left, Vector128<int> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<long> MultiplyWideningEven(Vector128<uint> left, Vector128<int> right) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// uint64x2_t vmulwod_d_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// int128x1_t vmulwev_q_du_s64 (uint64x2_t a, int64x2_t b)
+        ///   LSX: VMULWEV.Q.DU.D Vd.Q, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ulong> MultiplyWideningUpper(Vector128<uint> left, Vector128<uint> right) => MultiplyWideningUpper(left, right);
+        public static Vector128<long> MultiplyWideningEven(Vector128<ulong> left, Vector128<long> right) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// int8x16_t vssub_b_s8 (int8x16_t a, int8x16_t b)
+        /// int8x16_t vssub_b_s8(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_u8 (uint8x16_t a, uint8x16_t b)
+        /// uint8x16_t vssub_bu_u8(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_s16 (int16x8_t a, int16x8_t b)
+        /// int16x8_t vssub_h_s16(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_u16 (uint16x8_t a, uint16x8_t b)
+        /// uint16x8_t vssub_hu_u16(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_s32 (int32x4_t a, int32x4_t b)
+        /// int32x4_t vssub_w_s32(int32x4_t a, int32x4_t b)
         ///   LSX: VSSUB.W Vd.4S, Vj.4S, Vk.4S
         /// </summary>
         public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) => SubtractSaturate(left, right);
 
         /// <summary>
-        /// uint32x4_t vssub_wu_u32 (uint32x4_t a, uint32x4_t b)
+        /// uint32x4_t vssub_wu_u32(uint32x4_t a, uint32x4_t b)
         ///   LSX: VSSUB.WU Vd.4S, Vj.4S, Vk.4S
         /// </summary>
         public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) => SubtractSaturate(left, right);
 
         /// <summary>
-        /// int64x2_t vssub_d_s64 (int64x2_t a, int64x2_t b)
+        /// int64x2_t vssub_d_s64(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_u64 (uint64x2_t a, uint64x2_t b)
+        /// uint64x2_t vssub_du_u64(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 vavg_b_s8 (int8x16_t a, int8x16_t b)
+        /// int8x16_t vavg_b_s8(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_u8 (uint8x16_t a, uint8x16_t b)
+        /// uint8x16_t vavg_bu_u8(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_s16 (int16x8_t a, int16x8_t b)
+        /// int16x8_t vavg_h_s16(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_u16 (uint16x8_t a, uint16x8_t b)
+        /// uint16x8_t vavg_hu_u16(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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VAVG.W Vd.4S, Vj.4S, Vk.4S
+        /// int32x4_t vavg_w_s32(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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VAVG.WU Vd.4S, Vj.4S, Vk.4S
+        /// uint32x4_t vavg_wu_u32(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_s64 (int64x2_t a, int64x2_t b)
+        /// int64x2_t vavg_d_s64(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_u64 (uint64x2_t a, uint64x2_t b)
+        /// uint64x2_t vavg_du_u64(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>
-        /// int16x8_t vext2xv_h_b_s8 (int8x16_t a)
-        ///   LSX: VEXT2XV.H.B Vd.8H, Vj.16B
+        /// int16x8_t vsllwil_h_b_s8(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.H.B Vd.8H, Vj.16B, ui3
         /// </summary>
-        public static Vector128<short> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
+        public static Vector128<short> SignExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) => SignExtendWideningLowerAndShiftLeft(value, shift);
 
-        ///// <summary>
-        ///// int32x4_t vext2xv_w_b_s8 (int8x16_t a)
-        /////   LSX: VEXT2XV.W.B Vd.4W, Vj.16B
-        ///// </summary>
-        //public static Vector128<int> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
-
-        ///// <summary>
-        ///// int64x2_t vext2xv_d_b_s8 (int8x16_t a)
-        /////   LSX: VEXT2XV.D.B Vd.2D, Vj.16B
-        ///// </summary>
-        //public static Vector128<long> SignExtendWideningLower(Vector128<sbyte> value) => SignExtendWideningLower(value);
+        /// <summary>
+        /// int32x4_t vsllwil_w_h_s16(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>
-        /// int32x4_t vext2xv_w_h_s16 (int16x8_t a)
-        ///   LSX: VEXT2XV.W.H Vd.4W, Vj.8H
+        /// int64x2_t vsllwil_d_w_s32(int32x2_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.D.W Vd.2D, Vj.2W, ui5
         /// </summary>
-        public static Vector128<int> SignExtendWideningLower(Vector128<short> value) => SignExtendWideningLower(value);
+        public static Vector128<long> SignExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) => SignExtendWideningLowerAndShiftLeft(value, shift);
 
-        ///// <summary>
-        ///// int64x2_t vext2xv_d_h_s16 (int16x8_t a)
-        /////   LSX: VEXT2XV.D.H Vd.2D, Vj.8H
-        ///// </summary>
-        //public static Vector128<long> SignExtendWideningLower(Vector128<short> value) => SignExtendWideningLower(value);
+        /// <summary>
+        /// uint16x8_t vsllwil_hu_bu_u8(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>
-        /// int64x2_t vext2xv_d_w_s32 (int32x4_t a)
-        ///   LSX: VEXT2XV.D.W Vd.2D, Vj.4W
+        /// int16x8_t vsllwil_hu_bu_s8(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.HU.BU Vd.8H, Vj.16B, ui3
         /// </summary>
-        public static Vector128<long> SignExtendWideningLower(Vector128<int> value) => SignExtendWideningLower(value);
+        public static Vector128<short> ZeroExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
 
         /// <summary>
-        /// uint16x8_t vext2xv_hu_bu_u8 (uint8x16_t a)
-        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// uint32x4_t vsllwil_wu_hu_u16(uint16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
         /// </summary>
-        public static Vector128<ushort> ZeroExtendWideningLower(Vector128<byte> value) => ZeroExtendWideningLower(value);
+        public static Vector128<uint> ZeroExtendWideningLowerAndShiftLeft(Vector64<ushort> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
 
         /// <summary>
-        /// int16x8_t vext2xv_hu_bu_u8 (int8x16_t a)
-        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// int32x4_t vsllwil_wu_hu_s16(int16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ZeroExtendWideningLower(Vector128<sbyte> value) => ZeroExtendWideningLower(value);
+        public static Vector128<int> ZeroExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
 
         /// <summary>
-        /// uint32x4_t vext2xv_wu_hu_u16 (uint16x8_t a)
-        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// uint64x2_t vsllwil_du_wu_u32(uint32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
         /// </summary>
-        public static Vector128<uint> ZeroExtendWideningLower(Vector128<ushort> value) => ZeroExtendWideningLower(value);
+        public static Vector128<ulong> ZeroExtendWideningLowerAndShiftLeft(Vector64<uint> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
 
         /// <summary>
-        /// int32x4_t vext2xv_wu_hu_u16 (int16x8_t a)
-        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// int64x2_t vsllwil_du_wu_s32(int32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
         /// </summary>
-        public static Vector128<int> ZeroExtendWideningLower(Vector128<short> value) => ZeroExtendWideningLower(value);
+        public static Vector128<long> ZeroExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
 
         /// <summary>
-        /// uint64x2_t vext2xv_du_wu_u32 (uint32x4_t a)
-        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// uint128x1_t vextl_qu_du_s64(int64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
         /// </summary>
-        public static Vector128<ulong> ZeroExtendWideningLower(Vector128<uint> value) => ZeroExtendWideningLower(value);
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<long> value) => ZeroExtendWideningLower(value);
 
         /// <summary>
-        /// int64x2_t vext2xv_du_wu_u32 (int32x4_t a)
-        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// uint128x1_t vextl_qu_du_u64(uint64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
         /// </summary>
-        public static Vector128<long> ZeroExtendWideningLower(Vector128<int> value) => ZeroExtendWideningLower(value);
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<ulong> value) => ZeroExtendWideningLower(value);
 
         /// <summary>
-        /// int16x8_t vexth_h_b_s8 (int8x16_t a)
+        /// int16x8_t vexth_h_b_s8(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_s16 (int16x8_t a)
-        ///   LSX: VEXTH.W.H Vd.4S, Vj.8H
+        /// int32x4_t vexth_w_h_s16(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_s32 (int32x4_t a)
-        ///   LSX: VEXTH.D.W Vd.2D, Vj.4S
+        /// int64x2_t vexth_d_w_s32(int32x4_t a)
+        ///   LSX: VEXTH.D.W Vd.2D, Vj.4W
         /// </summary>
         public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) => SignExtendWideningUpper(value);
 
         /// <summary>
-        /// uint16x8_t vexth_HU_BU_u8 (uint8x16_t a)
+        /// int128x1_t vexth_d_w_s64(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_s8(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_u8 (uint8x16_t a)
+        /// uint16x8_t vexth_HU_BU_u8(uint8x16_t a)
         ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
         /// </summary>
         public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) => ZeroExtendWideningUpper(value);
 
         /// <summary>
-        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
-        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// int32x4_t vexth_WU_HU_s16(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_u16 (uint16x8_t a)
-        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// uint32x4_t vexth_WU_HU_u16(uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4W, Vj.8H
         /// </summary>
         public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) => ZeroExtendWideningUpper(value);
 
         /// <summary>
-        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
-        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// int64x2_t vexth_DU_WU_s32(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_u32 (uint32x4_t a)
-        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// uint64x2_t vexth_DU_WU_u32(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_s64(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_u64(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_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
@@ -1738,6 +1966,66 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) => AndNot(left, right);
 
+        /// <summary>
+        /// uint8x8_t vor_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
@@ -1799,73 +2087,253 @@ internal Lsx() { }
         public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) => Or(left, right);
 
         /// <summary>
-        /// int8x16_t vor_v_s8 (int8x16_t a, int8x16_t b)
+        /// uint8x8_t vnori_b_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (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 vor_v_u8 (uint8x16_t a, uint8x16_t b)
+        /// uint8x16_t vnor_v_u8 (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 vor_v_s16 (int16x8_t a, int16x8_t b)
+        /// int16x8_t vnor_v_s16 (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 vor_v_u16 (uint16x8_t a, uint16x8_t b)
+        /// uint16x8_t vnor_v_u16 (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 vor_v_s32 (int32x4_t a, int32x4_t b)
+        /// int32x4_t vnor_v_s32 (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 vor_v_u32 (uint32x4_t a, uint32x4_t b)
+        /// uint32x4_t vnor_v_u32 (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 vor_v_s64 (int64x2_t a, int64x2_t b)
+        /// int64x2_t vnor_v_s64 (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 vor_v_u64 (uint64x2_t a, uint64x2_t b)
+        /// uint64x2_t vnor_v_u64 (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 vor_v_f32 (float32x4_t a, float32x4_t b)
+        /// float32x4_t vnor_v_f32 (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 vor_v_f64 (float64x2_t a, float64x2_t b)
+        /// float64x2_t vnor_v_f64 (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>
-        /// int8x16_t vor_v_s8 (int8x16_t a, int8x16_t b)
+        /// uint8x8_t vorn_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (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 vor_v_u8 (uint8x16_t a, uint8x16_t b)
+        /// uint8x16_t vorn_v_u8 (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);
@@ -1883,41 +2351,101 @@ internal Lsx() { }
         public static Vector128<ushort> OrNot(Vector128<ushort> left, Vector128<ushort> right) => OrNot(left, right);
 
         /// <summary>
-        /// int32x4_t vor_v_s32 (int32x4_t a, int32x4_t b)
+        /// int32x4_t vorn_v_s32 (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 vor_v_u32 (uint32x4_t a, uint32x4_t b)
+        /// uint32x4_t vorn_v_u32 (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 vor_v_s64 (int64x2_t a, int64x2_t b)
+        /// int64x2_t vorn_v_s64 (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 vor_v_u64 (uint64x2_t a, uint64x2_t b)
+        /// uint64x2_t vorn_v_u64 (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 vor_v_f32 (float32x4_t a, float32x4_t b)
+        /// float32x4_t vorn_v_f32 (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 vor_v_f64 (float64x2_t a, float64x2_t b)
+        /// float64x2_t vorn_v_f64 (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_u8 (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_f64 (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_s16 (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_s32 (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_s64 (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_s8 (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_f32 (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_u16 (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_u32 (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_u64 (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_s8 (int8x16_t a, int8x16_t b)
         ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
@@ -2535,6 +3063,7 @@ internal Lsx() { }
         ///   LSX: VSETANYEQZ.D cd, Vj.2D
         /// </summary>
         public static bool HasElementsIsZero(Vector128<long> value) => HasElementsIsZero(value);
+
         /// <summary>
         /// bool vsetanyeqz_w_u64 (uint64x2_t value)
         ///   LSX: VSETANYEQZ.D cd, Vj.2D

From 7a4f56a0b0d69f1819439a52fae79e67fbbc3f17 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Tue, 21 Nov 2023 10:18:14 +0800
Subject: [PATCH 05/11] Lsx-PartC, Lasx-PartB: some Shifting operations with
 narrowing and rounding. Count leading ones/zeros and elements' bit clear.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 1482 ++++++++++++++--
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 1528 +++++++++++++++--
 2 files changed, 2726 insertions(+), 284 deletions(-)

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
index f866911af20d5b..ad1226499c4958 100644
--- 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
@@ -1880,62 +1880,6 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<ulong> value) => ZeroExtendWideningUpperEach128(value);
 
-
-        ------------------------
-        ///// <summary>
-        ///// int16x16_t xvexth_h_b_s8 (int8x32_t a)
-        /////   LASX: XVEXTH.H.B Xd.16H, Xj.32B
-        ///// </summary>
-        //public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) => SignExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// int32x8_t xvexth_w_h_s16 (int16x16_t a)
-        /////   LASX: XVEXTH.W.H Xd.8S, Xj.16H
-        ///// </summary>
-        //public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) => SignExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// int64x4_t xvexth_d_w_s32 (int32x8_t a)
-        /////   LASX: XVEXTH.D.W Xd.4D, Xj.8S
-        ///// </summary>
-        //public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) => SignExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
-        /////   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
-        ///// </summary>
-        //public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) => ZeroExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
-        /////   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
-        ///// </summary>
-        //public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) => ZeroExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
-        /////   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
-        ///// </summary>
-        //public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) => ZeroExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
-        /////   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
-        ///// </summary>
-        //public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) => ZeroExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        /////   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
-        ///// </summary>
-        //public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) => ZeroExtendWideningUpper(value);
-
-        ///// <summary>
-        ///// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        /////   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
-        ///// </summary>
-        //public static Vector256<ulong> ZeroExtendWideningUpper(Vector256<uint> value) => ZeroExtendWideningUpper(value);
-
         /// <summary>
         /// int8x32_t xvand_v_s8 (int8x32_t a, int8x32_t b)
         ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
@@ -2417,196 +2361,608 @@ internal Lasx() { }
         public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) => Xor(left, right);
 
         /// <summary>
-        /// int8x32_t xvslli_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        /// int8x32_t xvslli_b_s8 (int8x32_t a, const int n) //qiaoqiao.ok
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint8x32_t xvslli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// int16x16_t xvslli_h_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint16x16_t xvslli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint32x8_t xvslli_w_s32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint32x8_t xvslli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// int64x4_t xvslli_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint64x4_t xvslli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// int8x32_t xvsll_b_s8 (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 xvsrli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        /// uint8x32_t xvsll_b_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// int8x32_t xvsrl_b_s8 (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 xvsrlri_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        /// uint8x32_t xvsrl_b_u8 (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_s16 (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_u16 (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_s32 (int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRL.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector256<int> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8 xvsrl_w_u32 (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_s64 (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_u64 (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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok.
+        ///   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_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_u16 (uint16x16_t left, uint16x16_t right, const int n)  qiaoqiao.ok.
+        ///   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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrlrni_b_h_s16 (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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrlrni_h_w_s32 (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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrlrni_h_w_u32 (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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrlrni_w_d_s64 (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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrlrni_w_d_u64 (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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvsrlrni_d_q_s128 (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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvsrlrn_b_h_s16 (int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        ///   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_u16 (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_s32 (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_u32 (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_s64 (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_s64 (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_s16 (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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrarni_h_w_s32 (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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrarni_w_d_s64 (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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvsrarni_d_q_s128 (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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvsrarn_b_h_s16 (int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        ///   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_s32 (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_u32 (uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRARN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
 
         /// <summary>
-        /// int8x32_t xvsrai_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, #n
+        /// int32x4_t xvsrarn_w_d_s64 (int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRARN.W.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrai_b_s8 (int8x32_t a, const int n)//qiaoqiao.ok.
+        ///   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_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, const byte shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
         /// int32x8_t xvsrai_w_s32 (int32x8_t a, const int n)
-        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, ui5
         /// </summary>
-        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, const byte shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
         /// int64x4_t xvsrai_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, #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_s8 (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_s16 (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_s32 (int32x8_t value, int32x8_t shift)
+        ///   LASX:  XVSRA.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
-        /// int8x32_t xvsrari_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, #n
+        /// int64x4xvsra_d_s64 (int64x4_t value, int64x4_t shift)
+        ///   LASX:  XVSRA.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrari_b_s8 (int8x32_t a, const int n) //qiaoqiao.ok.
+        ///   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_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, #n
+        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
 
         /// <summary>
         /// int32x8_t xvsrari_w_s32 (int32x8_t a, const int n)
-        ///   LASX: XVSRARI.W Xd.8S, Xj.8S, #n
+        ///   LASX: XVSRARI.W Xd.8W, Xj.8W, ui5
         /// </summary>
-        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
 
         /// <summary>
         /// int64x4_t xvsrari_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, #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_s8 (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_s16 (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_s32 (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_s64 (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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok.
+        ///   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_u8 (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_u16 (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_u16 (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_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8S, Xj.8S, ui5
+        /// </summary>
+        public static Vector256<int> RotateRight(Vector256<int> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvrotri_w_u32 (uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8S, Xj.8S, ui5
+        /// </summary>
+        public static Vector256<uint> RotateRight(Vector256<uint> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvrotri_d_u64 (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_u64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (int64x4_t value, int64x4_t shift)
+        ///   LASX: XVROTR.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector256<long> RotateRight(Vector256<long> value, Vector256<long> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x4 xvrotr_d_u64 (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 xvadda_b_s8 (int8x32_t a)
@@ -2969,40 +3325,592 @@ internal Lasx() { }
         public static bool HasElementsIsZero(Vector256<ulong> value) => HasElementsIsZero(value);
 
         /// <summary>
-        /// int8x32_t xvpcnt_b_s8 (int8x32_t a)
-        ///   LASX: XVPCNT_B Xd, Xj
+        /// int8x32 xvsrlni_b_h_s16 (int16x16_t left, int16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
         /// </summary>
-        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) => PopCount(value);
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint8x32_t xvpcnt_b_u8 (uint8x32_t a)
-        ///   LASX: XVPCNT_B Xd, Xj
+        /// uint8x32 xvsrlni_b_h_u16 (uint16x16_t left, uint16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
         /// </summary>
-        public static Vector256<byte> PopCount(Vector256<byte> value) => PopCount(value);
+        public static Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int16x16_t xvpcnt_h_s16 (int16x16_t a)
-        ///   LASX: XVPCNT_H Xd, Xj
+        /// int16x16 xvsrlni_h_w_s32 (int32x8_t left, int32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
         /// </summary>
-        public static Vector256<short> PopCount(Vector256<short> value) => PopCount(value);
+        public static Vector256<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint16x16_t xvpcnt_h_u16 (uint16x16_t a)
-        ///   LASX: XVPCNT_H Xd, Xj
+        /// uint16x16 xvsrlni_h_w_u32 (uint32x8_t left, uint32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
         /// </summary>
-        public static Vector256<ushort> PopCount(Vector256<ushort> value) => PopCount(value);
+        public static Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int32x8_t xvpcnt_w_s32 (int32x8_t a)
-        ///   LASX: XVPCNT_W Xd, Xj
+        /// int32x8 xvsrlni_w_d_s64 (int64x4_t left, int64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
         /// </summary>
-        public static Vector256<int> PopCount(Vector256<int> value) => PopCount(value);
+        public static Vector256<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint32x8_t xvpcnt_w_u32 (uint32x8_t a)
-        ///   LASX: XVPCNT_W Xd, Xj
+        /// uint32x8 xvsrlni_w_d_u64 (uint64x4_t left, uint64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
         /// </summary>
-        public static Vector256<uint> PopCount(Vector256<uint> value) => PopCount(value);
+        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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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_s8 (int8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x32_t xvpcnt_b_u8 (uint8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<byte> PopCount(Vector256<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x16_t xvpcnt_h_s16 (int16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<short> PopCount(Vector256<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x16_t xvpcnt_h_u16 (uint16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<ushort> PopCount(Vector256<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x8_t xvpcnt_w_s32 (int32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<int> PopCount(Vector256<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x8_t xvpcnt_w_u32 (uint32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<uint> PopCount(Vector256<uint> value) => PopCount(value);
 
         /// <summary>
         /// int64x4_t xvpcnt_d_s64 (int64x4_t a)
@@ -3064,6 +3972,294 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<ulong> VectorElementReplicate(Vector256<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
+        /// <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.4S, Xj.4S, 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.4S, Xj.4S, 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.4S, Xj.4S, 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.4S, Xj.4S, 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.4S, Xj.4S, 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.4S, Xj.4S, 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);
+
         // TODO:----------------------------------
     }
 }
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
index 04b4de52f33efe..31bc2dc9d12a06 100644
--- 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
@@ -2507,196 +2507,610 @@ internal Lsx() { }
         public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) => Xor(left, right);
 
         /// <summary>
-        /// int8x16_t vslli_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        /// int8x16_t vslli_b_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint8x16_t vslli_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// int16x8_t vslli_h_s16 (int16x8_t a, const int n)
-        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint16x8_t vslli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint32x4_t vslli_w_s32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint32x4_t vslli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSLLI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// int64x2_t vslli_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
         /// uint64x2_t vslli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        /// int8x16_t vsll_b_u8 (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_u8 (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_s16 (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_s16 (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_s32 (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_s32 (uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSLL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsll_d_s64 (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_u64 (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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        ///   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_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRLI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
         /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, const byte shift) => ShiftRightLogical(value, shift);
 
         /// <summary>
-        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        /// int8x16_t vsrl_b_u8 (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_u8 (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_s16 (int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRL.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrl_h_s16 (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_s32 (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_s32 (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_s64 (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_u64 (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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        ///   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_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
 
         /// <summary>
         /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (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_u16 (uint16x8_t left, uint16x8_t right, const int n)  qiaoqiao.ok.
+        ///   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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t vsrlrni_b_h_s16 (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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vsrlrni_h_w_s32 (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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlrni_h_w_u32 (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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vsrlrni_w_d_s64 (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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlrni_w_d_u64 (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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vsrlrni_d_q_s128 (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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vsrlrn_b_h_s16 (int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
 
         /// <summary>
-        /// int8x16_t vsrai_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSRAI.B Vd.16B, Vj.16B, #n
+        /// uint8x8_t vsrlrn_b_h_u16 (uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vsrlrn_h_w_s32 (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_u32 (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_s64 (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_s64 (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_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        ///   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_s16 (int16x8_t a, const int n)
-        ///   LSX: VSRAI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRAI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, const byte shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
         /// int32x4_t vsrai_w_s32 (int32x4_t a, const int n)
-        ///   LSX: VSRAI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRAI.W Vd.4S, Vj.4S, ui5
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, const byte shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
         /// int64x2_t vsrai_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSRAI.D Vd.2D, Vj.2D, #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_u8 (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_s16 (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_s32 (int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRA.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmetic(value, shift);
 
         /// <summary>
-        /// int8x16_t vsrari_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSRARI.B Vd.16B, Vj.16B, #n
+        /// int64x2_t vsra_d_s64 (int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRA.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrari_b_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        ///   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_s16 (int16x8_t a, const int n)
-        ///   LSX: VSRARI.H Vd.8H, Vj.8H, #n
+        ///   LSX: VSRARI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
 
         /// <summary>
         /// int32x4_t vsrari_w_s32 (int32x4_t a, const int n)
-        ///   LSX: VSRARI.W Vd.4S, Vj.4S, #n
+        ///   LSX: VSRARI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
 
         /// <summary>
         /// int64x2_t vsrari_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSRARI.D Vd.2D, Vj.2D, #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_s8 (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_s16 (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_s32 (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_s64 (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_s16 (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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vsrarni_h_w_s32 (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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vsrarni_w_d_s64 (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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vsrarni_d_q_s128 (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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vsrarn_b_h_s16 (int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        ///   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_s32 (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_u32 (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_s64 (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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        ///   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_u8 (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_u16 (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_u16 (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_u32 (uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4S, Vj.4S, ui5
+        /// </summary>
+        public static Vector128<int> RotateRight(Vector128<int> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vrotri_w_u32 (uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4S, Vj.4S, ui5
+        /// </summary>
+        public static Vector128<uint> RotateRight(Vector128<uint> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vrotri_d_u64 (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_u64 (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_s8 (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_u8 (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_s16 (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_u16 (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_s32 (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_u32 (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_s64 (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_u64 (uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VROTR.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<ulong> RotateRight(Vector128<ulong> value, Vector128<ulong> shift) => RotateRight(value, shift);
 
         /// <summary>
         /// int8x16_t vadda_b_s8 (int8x16_t a)
@@ -2892,13 +3306,13 @@ internal Lsx() { }
 
         /// <summary>
         /// int32x4_t vreplgr2vr_w_s32 (int32_t value)
-        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
         /// </summary>
         public static Vector128<int> DuplicateToVector128(int value) => DuplicateToVector128(value);
 
         /// <summary>
         /// uint32x4_t vreplgr2vr_w_u32 (uint32_t value)
-        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
         /// </summary>
         public static Vector128<uint> DuplicateToVector128(uint value) => DuplicateToVector128(value);
 
@@ -2928,13 +3342,13 @@ internal Lsx() { }
 
         /// <summary>
         /// float32x4_t vffint_s_w_f32_s32 (int32x4_t a)
-        ///   LSX: VFFINT.S.W Vd.4S, Vj.4S
+        ///   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_f32_u32 (uint32x4_t a)
-        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4S
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4W
         /// </summary>
         public static Vector128<float> ConvertToSingle(Vector128<uint> value) => ConvertToSingle(value);
 
@@ -3071,130 +3485,676 @@ internal Lsx() { }
         public static bool HasElementsIsZero(Vector128<ulong> value) => HasElementsIsZero(value);
 
         /// <summary>
-        /// ulong vsrlni_b_h_16 (int16x8_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
-        ///   LSX: Vd Scalar to uint64.
-        /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<short> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
-
-        /// <summary>
-        /// ulong vsrlni_b_h_u16 (uint16x8_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
+        /// uint8x16_t vsrlni_b_h_u16 (uint16x8_t left, uint16x8_t right, shift)
         ///   LSX: VSRLNI.B.H Vd, Vj, ui4
-        ///   LSX: Vd Scalar to uint64.
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ushort> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// ulong vsrlni_h_w_s32 (int32x4_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
+        /// int16x8_t vsrlni_h_w_s32 (int32x4_t left, int32x4_t right, shift)
         ///   LSX: VSRLNI.H.W Vd, Vj, ui5
-        ///   LSX: Vd Scalar to uint64.
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<int> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// ulong vsrlni_h_w_u32 (uint32x4_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
+        /// uint16x8_t vsrlni_h_w_u32 (uint32x4_t left, uint32x4_t right, shift)
         ///   LSX: VSRLNI.H.W Vd, Vj, ui5
-        ///   LSX: Vd Scalar to uint64.
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<uint> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// ulong vsrlni_w_d_s64 (int64x2_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
+        /// int32x4_t vsrlni_w_d_s64 (int64x2_t left, int64x2_t right, shift)
         ///   LSX: VSRLNI.W.D Vd, Vj, ui6
-        ///   LSX: Vd Scalar to uint64.
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<long> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// ulong vsrlni_w_d_u64 (uint64x2_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
+        /// uint32x4_t vsrlni_w_d_u64 (uint64x2_t left, uint64x2_t right, shift)
         ///   LSX: VSRLNI.W.D Vd, Vj, ui6
-        ///   LSX: Vd Scalar to uint64.
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ulong> value, byte shift) => ShiftRightLogicalNarrowingLowerScalar(value, shift);
+        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vsrlni_d_q_u128 (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>
-        /// uint8x16 vsrlni_b_h_u16 (uint16x8_t left, uint16x8_t right, shift)
-        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        /// int8x8_t vsrln_b_h_s16 (int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// int16x8 vsrlni_h_w_s32 (int32x4_t left, int32x4_t right, shift)
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// uint8x8_t vsrln_b_h_u16 (uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// uint16x8 vsrlni_h_w_u32 (uint32x4_t left, uint32x4_t right, shift)
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// int16x4_t vsrln_h_w_s32 (int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// int32x4 vsrlni_w_d_s64 (int64x2_t left, int64x2_t right, shift)
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// uint16x4_t vsrln_h_w_u32 (uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// uint32x4 vsrlni_w_d_u64 (uint64x2_t left, uint64x2_t right, shift)
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// int32x2_t vsrln_w_d_s64 (int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// int8x16_t vpcnt_b_s8 (int8x16_t a)
-        ///   LSX: VPCNT_B Vd, Vj
+        /// uint32x2_t vsrln_w_d_u64 (uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) => PopCount(value);
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalNarrowingLower(value, shift);
 
         /// <summary>
-        /// uint8x16_t vpcnt_b_u8 (uint8x16_t a)
-        ///   LSX: VPCNT_B Vd, Vj
+        /// 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<byte> PopCount(Vector128<byte> value) => PopCount(value);
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// int16x8_t vpcnt_h_s16 (int16x8_t a)
-        ///   LSX: VPCNT_H Vd, Vj
+        /// 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<short> PopCount(Vector128<short> value) => PopCount(value);
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// uint16x8_t vpcnt_h_u16 (uint16x8_t a)
-        ///   LSX: VPCNT_H Vd, Vj
+        /// 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<ushort> PopCount(Vector128<ushort> value) => PopCount(value);
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// int32x4_t vpcnt_w_s32 (int32x4_t a)
-        ///   LSX: VPCNT_W Vd, Vj
+        /// 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<int> PopCount(Vector128<int> value) => PopCount(value);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// uint32x4_t vpcnt_w_u32 (uint32x4_t a)
-        ///   LSX: VPCNT_W Vd, Vj
+        /// 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<uint> PopCount(Vector128<uint> value) => PopCount(value);
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// int64x2_t vpcnt_d_s64 (int64x2_t a)
-        ///   LSX: VPCNT_D Vd, Vj
+        /// 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<long> PopCount(Vector128<long> value) => PopCount(value);
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
 
         /// <summary>
-        /// uint64x2_t vpcnt_d_u64 (uint64x2_t a)
-        ///   LSX: VPCNT_D Vd, Vj
+        /// int8x8_t vssrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> PopCount(Vector128<ulong> value) => PopCount(value);
+        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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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_s8 (int8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x16_t vpcnt_b_u8 (uint8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<byte> PopCount(Vector128<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x8_t vpcnt_h_s16 (int16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<short> PopCount(Vector128<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x8_t vpcnt_h_u16 (uint16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<ushort> PopCount(Vector128<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x4_t vpcnt_w_s32 (int32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<int> PopCount(Vector128<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x4_t vpcnt_w_u32 (uint32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<uint> PopCount(Vector128<uint> value) => PopCount(value);
+
+        /// <summary>
+        /// int64x2_t vpcnt_d_s64 (int64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<long> PopCount(Vector128<long> value) => PopCount(value);
+
+        /// <summary>
+        /// uint64x2_t vpcnt_d_u64 (uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) => PopCount(value);
 
         /// <summary>
         ///  uint8x16_t vshuffle_u8(uint8x16_t vec, uint8x16_t idx)
@@ -3324,9 +4284,295 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<ulong> VectorElementReplicate(Vector128<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
+        /// <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.4S, Vj.4S, 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.4S, Vj.4S, 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.4S, Vj.4S, 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.4S, Vj.4S, 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.4S, Vj.4S, 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.4S, Vj.4S, 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);
 
-        // TODO: other liking vsrani .......
+        // TODO: other liking .......
         // TODO:----------------------------------
 
     }

From dd8fb3d26e58e2bfa538a05a93029a0ce3e266e7 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Thu, 23 Nov 2023 15:58:41 +0800
Subject: [PATCH 06/11] Lsx-PartD, Lasx-PartC: amend the code formate. Add more
 ADD's operations.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 1956 ++++++++------
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 2343 ++++++++++-------
 2 files changed, 2527 insertions(+), 1772 deletions(-)

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
index ad1226499c4958..d1f7f3b77ad80b 100644
--- 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
@@ -17,3345 +17,3693 @@ internal Lasx() { }
         public static new bool IsSupported { get => IsSupported; }
 
         /// <summary>
-        /// int8x32_t xvadd_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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 TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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 TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVADD.W Xd.8S, Xj.8S, Xk.8S
+        /// 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 TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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 TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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 xvsub_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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 TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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 TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// 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 TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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 TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// int8x32_t xvmul_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        /// float32x8_t xvfmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
         ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
         /// </summary>
         public static Vector256<float> FusedMultiplyAdd(Vector256<float> addend, Vector256<float> left, Vector256<float> right) => FusedMultiplyAdd(addend, left, right);
 
         /// <summary>
-        /// float64x4_t xvfmadd_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        /// float64x4_t xvfmadd_d(float64x4_t a, float64x4_t b, float64x4_t c)
         ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
         public static Vector256<double> FusedMultiplyAdd(Vector256<double> addend, Vector256<double> left, Vector256<double> right) => FusedMultiplyAdd(addend, left, right);
 
         /// <summary>
-        /// int8x32_t xvmadd_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
+        /// int8x32_t xvmadd_b(int8x32_t a, int8x32_t b, int8x32_t c)
         ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
         public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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_s16 (int16x16_t a, int16x16_t b, int16x16_t c)
+        /// 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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMADD.W Xd.8S, Xj.8S, Xk.8S
+        /// 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 TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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>
-        /// int8x32_t TODO_s8 (int8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B
-        /// </summary>
-        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<byte> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, int8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B
-        /// </summary>
-        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<sbyte> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// int16x16_t TODO_s16 (int16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H
-        /// </summary>
-        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<ushort> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, int16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H
-        /// </summary>
-        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<short> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// int32x8_t TODO_s32 (int32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S
-        /// </summary>
-        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<uint> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, int32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S
-        /// </summary>
-        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<int> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// int64x4_t TODO_s64 (int64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D
-        /// </summary>
-        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<ulong> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// uint64x4_t TODO_u64 (uint64x4_t a, int64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D
-        /// </summary>
-        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<long> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// int8x32_t xvsadd_b_s8 (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_s16 (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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSADD.W Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// int64x4_t xvsadd_d_s64 (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_u8 (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_u16 (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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSADD.WU Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) => AddSaturate(left, right);
-
-        /// <summary>
-        /// uint64x4_t xvsadd_du_u64 (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>
-        /// int8x32_t xvmsub_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
+        /// 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 TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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_s16 (int16x16_t a, int16x16_t b, int16x16_t c)
+        /// 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 TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// 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 TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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>
-        /// int16x16_t xvmaddwev_h_b_s8 (int16x16_t a, int8x8_t b, int8x8_t c)
+        /// 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_u8 (uint16x16_t a, uint8x8_t b, uint8x8_t c)
+        /// 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_s16 (int32x8_t a, int16x4_t b, int16x4_t c)
-        ///   LASX: XVMADDWEV.W.H Xd.8S, Xj.4H, Xk.4H
+        /// 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_u16 (uint32x8_t a, uint16x4_t b, uint16x4_t c)
-        ///   LASX: XVMADDWEV.W.HU Xd.8S, Xj.4H, Xk.4H
+        /// 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_s32 (int64x4_t a, int32x2_t b, int32x2_t c)
+        /// 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_u32 (uint64x4_t a, uint32x2_t b, uint32x2_t c)
+        /// 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_s8 (int16x16_t a, int8x32_t b, int8x32_t c)
+        /// 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_u8 (uint16x16_t a, uint8x32_t b, uint8x32_t c)
+        /// 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_s16 (int32x8_t a, int16x16_t b, int16x16_t c)
-        ///   LASX: XVMADDWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// 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_u16 (uint32x8_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: XVMADDWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// 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_s32 (int64x4_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// 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_u32 (uint64x4_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// 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>
-        /// uint8x32_t xvseq_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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))] const 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))] const 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))] const 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))] const 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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>
-        /// uint16x16_t xvseq_h_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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>
-        /// uint32x8_t xvseq_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// 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>
-        /// uint64x4_t xvseq_d_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// uint8x32_t xvslt_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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))] const 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))] const 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))] const 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))] const 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_s8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_s16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_s32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_s64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// uint8x32_t xvsle_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// 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> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint8x32_t xvsle_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// int16x16_t xvslei_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSLEI.H Xd.16H, Xj.16H, si5
         /// </summary>
-        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint16x16_t xvsle_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// int32x8_t xvslei_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSLEI.W Xd.8W, Xj.8W, si5
         /// </summary>
-        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint16x16_t xvsle_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvslei_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSLEI.D Xd.4D, Xj.4D, si5
         /// </summary>
-        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint32x8_t xvsle_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvsle_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint16x16_t xvsle_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareLessThanOrEqual(left, right);
+        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_s64 (int64x4_t a, int64x4_t b)
+        /// 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>
-        /// uint64x4_t xvsle_du_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint64x4_t xvfcmp_cle_d_f64 (float64x4_t a, float64x4_t b)
+        /// 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> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right);
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint8x32_t xvsle_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// uint8x32_t xvslt_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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 xvmax_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMAX.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMAX.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVMAX.D Xd.8S, Xj.8S, Xk.8S
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVMAX.DU Xd.8S, Xj.8S, Xk.8S
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// int8x32_t xvmin_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMIN.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMIN.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVMIN.D Xd.8S, Xj.8S, Xk.8S
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVMIN.DU Xd.8S, Xj.8S, Xk.8S
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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>
-        /// int8x32_t xvbitsel_v_s8 (uint8x32_t a, int8x32_t b, int8x32_t c)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        /// 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_s16 (uint16x16_t a, int16x16_t b, int16x16_t c)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        /// 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_s32 (uint32x8_t a, int32x8_t b, int32x8_t c)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        /// 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_s64 (uint64x4_t a, int64x4_t b, int64x4_t c)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        /// 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_f32 (uint32x8_t a, float32x8_t b, float32x8_t c)
+        /// 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_f64 (uint64x4_t a, float64x4_t b, float64x4_t c)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVABSD.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVABSD.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (uint64x4_t a, int64x4_t b, int64x4_t c)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<float> AbsoluteDifference(Vector256<float> left, Vector256<float> 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_f64 (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>
+        ///// 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_s8 (int8_t const * ptr)
+        /// int8x32_t xvld(int8_t const * ptr)
         ///   LASX: XVLD Xd.32B, Rj, si12
         /// </summary>
         public static unsafe Vector256<sbyte> LoadVector256(sbyte* address) => LoadVector256(address);
 
         /// <summary>
-        /// uint8x32_t xvld_u8 (uint8_t const * ptr)
+        /// uint8x32_t xvld(uint8_t const * ptr)
         ///   LASX: XVLD Xd.32B, Rj, si12
         /// </summary>
         public static unsafe Vector256<byte> LoadVector256(byte* address) => LoadVector256(address);
 
         /// <summary>
-        /// int16x16_t xvld_s16 (int16_t const * ptr)
+        /// int16x16_t xvld(int16_t const * ptr)
         ///   LASX: XVLD Xd.16H, Rj, si12
         /// </summary>
         public static unsafe Vector256<short> LoadVector256(short* address) => LoadVector256(address);
 
         /// <summary>
-        /// uint16x16_t xvld_s16 (uint16_t const * ptr)
+        /// uint16x16_t xvld(uint16_t const * ptr)
         ///   LASX: XVLD Xd.16H, Rj, si12
         /// </summary>
         public static unsafe Vector256<ushort> LoadVector256(ushort* address) => LoadVector256(address);
 
         /// <summary>
-        /// int32x8_t xvld_s32 (int32_t const * ptr)
-        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// int32x8_t xvld(int32_t const * ptr)
+        ///   LASX: XVLD Xd.8W, Rj, si12
         /// </summary>
         public static unsafe Vector256<int> LoadVector256(int* address) => LoadVector256(address);
 
         /// <summary>
-        /// uint32x8_t xvld_s32 (uint32_t const * ptr)
-        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// uint32x8_t xvld(uint32_t const * ptr)
+        ///   LASX: XVLD Xd.8W, Rj, si12
         /// </summary>
         public static unsafe Vector256<uint> LoadVector256(uint* address) => LoadVector256(address);
 
         /// <summary>
-        /// int64x4_t xvld_s64 (int64_t const * ptr)
+        /// int64x4_t xvld(int64_t const * ptr)
         ///   LASX: XVLD Xd.4D, Rj, si12
         /// </summary>
         public static unsafe Vector256<long> LoadVector256(long* address) => LoadVector256(address);
 
         /// <summary>
-        /// uint64x4_t xvld_u64 (uint64_t const * ptr)
+        /// uint64x4_t xvld(uint64_t const * ptr)
         ///   LASX: XVLD Xd.4D, Rj, si12
         /// </summary>
         public static unsafe Vector256<ulong> LoadVector256(ulong* address) => LoadVector256(address);
 
         /// <summary>
-        /// float32x8_t xvld_f32 (float32_t const * ptr)
+        /// float32x8_t xvld(float32_t const * ptr)
         ///   LASX: XVLD Xd.8S, Rj, si12
         /// </summary>
         public static unsafe Vector256<float> LoadVector256(float* address) => LoadVector256(address);
 
         /// <summary>
-        /// float64x4_t xvld_f64 (float64_t const * ptr)
+        /// float64x4_t xvld(float64_t const * ptr)
         ///   LASX: XVLD Xd.4D, Rj, si12
         /// </summary>
         public static unsafe Vector256<double> LoadVector256(double* address) => LoadVector256(address);
 
         /// <summary>
-        /// float32x8_t xvfrecip_s_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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>
-        /// void xvst_s8 (int8_t * ptr, int8x32_t val)
+        /// void xvst(int8_t * ptr, int8x32_t val)
         ///   LASX: XVST { Xd.32B }, Rj, si12
         /// </summary>
         public static unsafe void Store(sbyte* address, Vector256<sbyte> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_u8 (uint8_t * ptr, uint8x32_t val)
+        /// void xvst(uint8_t * ptr, uint8x32_t val)
         ///   LASX: XVST { Xd.32B }, Rj, si12
         /// </summary>
         public static unsafe void Store(byte* address, Vector256<byte> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_s16 (int16_t * ptr, int16x16_t val)
+        /// void xvst(int16_t * ptr, int16x16_t val)
         ///   LASX: XVST { Xd.16H }, Rj, si12
         /// </summary>
         public static unsafe void Store(short* address, Vector256<short> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_u16 (uint16_t * ptr, uint16x16_t val)
+        /// void xvst(uint16_t * ptr, uint16x16_t val)
         ///   LASX: XVST { Xd.16H }, Rj, si12
         /// </summary>
         public static unsafe void Store(ushort* address, Vector256<ushort> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_s32 (int32_t * ptr, int32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// void xvst(int32_t * ptr, int32x8_t val)
+        ///   LASX: XVST { Xd.8W }, Rj, si12
         /// </summary>
         public static unsafe void Store(int* address, Vector256<int> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_u32 (uint32_t * ptr, uint32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// void xvst(uint32_t * ptr, uint32x8_t val)
+        ///   LASX: XVST { Xd.8W }, Rj, si12
         /// </summary>
         public static unsafe void Store(uint* address, Vector256<uint> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_s64 (int64_t * ptr, int64x4_t val)
+        /// void xvst(int64_t * ptr, int64x4_t val)
         ///   LASX: XVST { Xd.4D }, Rj, si12
         /// </summary>
         public static unsafe void Store(long* address, Vector256<long> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_u64 (uint64_t * ptr, uint64x4_t val)
+        /// void xvst(uint64_t * ptr, uint64x4_t val)
         ///   LASX: XVST { Xd.4D }, Rj, si12
         /// </summary>
         public static unsafe void Store(ulong* address, Vector256<ulong> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_f32 (float32_t * ptr, float32x8_t val)
+        /// void xvst(float32_t * ptr, float32x8_t val)
         ///   LASX: XVST { Xd.8W }, Rj, si12
         /// </summary>
         public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source);
 
         /// <summary>
-        /// void xvst_f64 (float64_t * ptr, float64x4_t val)
+        /// void xvst(float64_t * ptr, float64x4_t val)
         ///   LASX: XVST { Xd.4D }, Rj, si12
         /// </summary>
         public static unsafe void Store(double* address, Vector256<double> source) => Store(address, source);
 
         /// <summary>
-        /// int8x32_t xvneg_b_s8 (int8x32_t a)
+        /// 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_s16 (int16x16_t a)
+        /// 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_s32 (int32x8_t a)
+        /// 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_s64 (int64x4_t a)
+        /// 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 TODO_f32 (float32x8_t a)
-        ///   LASX: TODO Xd.8S, Xj.8S
+        /// 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 TODO_f64 (float64x4_t a)
-        ///   LASX: TODO Xd.4D, Xj.4D
+        /// 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>
-        /// float32x8_t xvfmsub_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
+        /// float32x8_t xvfmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
         ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S
         /// </summary>
         public static Vector256<float> FusedMultiplySubtract(Vector256<float> minuend, Vector256<float> left, Vector256<float> right) => FusedMultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// float64x4_t xvfmsub_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
+        /// float64x4_t xvfmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
         ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
         public static Vector256<double> FusedMultiplySubtract(Vector256<double> minuend, Vector256<double> left, Vector256<double> right) => FusedMultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// int16x16_t xvmulwod_h_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_s8 (uint8x32_t a, int8x32_t b)
+        /// 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_s16 (uint16x16_t a, int16x16_t b)
+        /// 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_s32 (uint32x8_t a, int32x8_t b)
+        /// 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_s64 (uint64x4_t a, int64x4_t b)
+        /// 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_s8 (uint8x32_t a, int8x32_t b)
+        /// 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_s16 (uint16x16_t a, int16x16_t b)
+        /// 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_s32 (uint32x8_t a, int32x8_t b)
+        /// 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_s64 (uint64x4_t a, int64x4_t b)
+        /// 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 xvssub_b_s8 (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_u8 (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_s16 (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_u16 (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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSSUB.W Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) => SubtractSaturate(left, right);
-
-        /// <summary>
-        /// uint32x8_t xvssub_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSSUB.WU Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) => SubtractSaturate(left, right);
-
-        /// <summary>
-        /// int64x4_t xvssub_d_s64 (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_u64 (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 xvavg_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVAVG.W Xd.8S, Xj.8S, Xk.8S
+        /// 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_u32(uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVAVG.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64(int64x4_t a, int64x4_t b)
+        /// 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_u64(uint64x4_t a, uint64x4_t b)
+        /// 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>
-        /// int16x16_t xvsllwil_h_b_s8(int8x32_t a, uint8_t ui3)
+        /// 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_u8(uint8x32_t a, uint8_t ui3)
+        /// 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_s16(int16x4_t a, uint8_t ui4)
+        /// 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_u16(uint16x4_t a, uint8_t ui4)
+        /// 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_s32(int32x2_t a, uint8_t ui5)
+        /// 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_u32(uint32x2_t a, uint8_t ui5)
+        /// 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_u8(uint8x32_t a, uint8_t ui3)
+        /// 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_s8(int8x32_t a, uint8_t ui3)
+        /// 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_u16(uint16x16_t a, uint8_t ui4)
+        /// 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_s16(int16x16_t a, uint8_t ui4)
+        /// 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_u32(uint32x8_t a, uint8_t ui5)
+        /// 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_s32(int32x8_t a, uint8_t ui5)
+        /// 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_s64(int64x4_t a)
+        /// 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_u64(uint64x4_t a)
+        /// 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_s8(int8x16_t a)
+        /// 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_u8(uint8x16_t a)
+        /// 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_s8(int8x8_t a)
+        /// 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_u8(uint8x8_t a)
+        /// 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_s8(int8x4_t a)
+        /// 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_u8(uint8x4_t a)
+        /// 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_s16(int16x8_t a)
+        /// 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_u16(uint16x8_t a)
+        /// 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_u16(int16x4_t a)
+        /// 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_u16(uint16x4_t a)
+        /// 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_s32(int32x2_t a)
+        /// 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_u32(uint32x2_t a)
+        /// 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_u8(uint8x16_t a)
+        /// 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_s8(int8x16_t a)
+        /// 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_u8(uint8x8_t a)
+        /// 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_s8(int8x8_t a)
+        /// 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_u8(uint8x4_t a)
+        /// 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_s8(int8x4_t a)
+        /// 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_u16(uint16x8_t a)
+        /// 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_s16(int16x8_t a)
+        /// 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_u16(uint16x4_t a)
+        /// 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_s16(int16x4_t a)
+        /// 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_u32(uint32x4_t a)
+        /// 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_s32(int32x4_t a)
+        /// 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_s8(int8x32_t a)
+        /// 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_s16(int16x16_t a)
+        /// 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_s32(int32x8_t a)
+        /// 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_s64(int64x4_t a)
+        /// 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_s8(int8x32_t a)
+        /// 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_u8(uint8x32_t a)
+        /// 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_s16(int16x16_t a)
+        /// 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_u16(uint16x16_t a)
+        /// 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_s32(uint32x8_t a)
+        /// 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_u32(uint32x8_t a)
+        /// 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_s64(int64x4_t a)
+        /// 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_u64(uint64x4_t a)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_u8 (uint8x32_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_s16 (int16x16_t a)
+        /// 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_s32 (int32x8_t a)
+        /// 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_s64 (int64x4_t a)
+        /// 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_s8 (int8x32_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_u16 (uint16x16_t a)
+        /// 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_u32 (uint32x8_t a)
+        /// 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_u64 (uint64x4_t a)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_u8 (uint8x8_t a, uint8x8_t b)
+        /// 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_f64 (float64x1_t a, float64x1_t b)
+        /// 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_s16 (int16x4_t a, int16x4_t b)
+        /// 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_s32 (int32x2_t a, int32x2_t b)
+        /// 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_s64 (int64x1_t a, int64x1_t b)
+        /// 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_s8 (int8x8_t a, int8x8_t b)
+        /// 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_f32 (float32x2_t a, float32x2_t b)
+        /// 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_u16 (uint16x4_t a, uint16x4_t b)
+        /// 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_u32 (uint32x2_t a, uint32x2_t b)
+        /// 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_u64 (uint64x1_t a, uint64x1_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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_u16 (uint16x16_t a, uint16x16_t b)
+        /// 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_s32 (int32x8_t a, int32x8_t b)
+        /// 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_u32 (uint32x8_t a, uint32x8_t b)
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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_u64 (uint64x4_t a, uint64x4_t b)
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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_s8 (int8x32_t a, const int n) //qiaoqiao.ok
+        /// int8x32_t xvslli_b(int8x32_t a, const int n) //qiaoqiao.ok
         ///   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_u8 (uint8x32_t a, const int n)
+        /// 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_s16 (int16x16_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_s32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, ui5
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, ui5
+        /// 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_s64 (int64x4_t a, const int n)
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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);
 
-        /// int8x32_t xvsll_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u64 (uint64x4_t value, uint64x4_t shift)
+        /// 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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok
+        /// uint8x32_t xvsrli_b(uint8x32_t a, const int n) //qiaoqiao.ok
         ///   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_u8 (uint8x32_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, ui5
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, ui5
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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);
 
-        /// int8x32_t xvsrl_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u64 (uint64x4_t value, uint64x4_t shift)
+        /// 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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok.
+        /// uint8x32_t xvsrlri_b(uint8x32_t a, const int n) //qiaoqiao.ok.
         ///   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_u8 (uint8x32_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, ui5
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, ui5
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u64 (uint64x4_t value, uint64x4_t shift)
+        /// 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_u16 (uint16x16_t left, uint16x16_t right, const int n)  qiaoqiao.ok.
+        /// uint8x32_t xvsrlrni_b_h(uint16x16_t left, uint16x16_t right, const int n)  qiaoqiao.ok.
         ///   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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int8x32_t xvsrlrni_b_h_s16 (int16x16_t left, int16x16_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int16x16_t xvsrlrni_h_w_s32 (int32x8_t left, int32x8_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint16x16_t xvsrlrni_h_w_u32 (uint32x8_t left, uint32x8_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int32x8_t xvsrlrni_w_d_s64 (int64x4_t left, int64x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint32x8_t xvsrlrni_w_d_u64 (uint64x4_t left, uint64x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         ///// <summary>
-        ///// int64x4_t xvsrlrni_d_q_s128 (int128x2_t left, int128x2_t right, const int n)
+        ///// 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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int8x16_t xvsrlrn_b_h_s16 (int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        /// int8x16_t xvsrlrn_b_h(int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
         ///   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_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_s64 (uint64x4_t value, uint64x4_t shift)
+        /// 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_s16 (int16x16_t left, int16x16_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int16x16_t xvsrarni_h_w_s32 (int32x8_t left, int32x8_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int32x8_t xvsrarni_w_d_s64 (int64x4_t left, int64x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
 
         ///// <summary>
-        ///// int64x4_t xvsrarni_d_q_s128 (int128x2_t left, int128x2_t right, const int n)
+        ///// 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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int8x16_t xvsrarn_b_h_s16 (int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        /// int8x16_t xvsrarn_b_h(int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
         ///   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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_s8 (int8x32_t a, const int n)//qiaoqiao.ok.
+        /// int8x32_t xvsrai_b(int8x32_t a, const int n)//qiaoqiao.ok.
         ///   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_s16 (int16x16_t a, const int n)
+        /// 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_s32 (int32x8_t a, const int n)
-        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, ui5
+        /// 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_s64 (int64x4_t a, const int n)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_s8 (int8x32_t a, const int n) //qiaoqiao.ok.
+        /// int8x32_t xvsrari_b(int8x32_t a, const int n) //qiaoqiao.ok.
         ///   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_s16 (int16x16_t a, const int n)
+        /// 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_s32 (int32x8_t a, const int n)
+        /// 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_s64 (int64x4_t a, const int n)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u8 (uint8x32_t a, const int n) //qiaoqiao.ok.
+        /// uint8x32_t xvrotri_b(uint8x32_t a, const int n) //qiaoqiao.ok.
         ///   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_u8 (uint8x32_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u16 (uint16x16_t a, const int n)
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVROTRI.W Xd.8S, Xj.8S, ui5
+        /// 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_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVROTRI.W Xd.8S, Xj.8S, ui5
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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_u64 (uint64x4_t a, const int n)
+        /// 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_s8 (int8x32_t a, int8x32_t b)
+        /// 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_u8 (uint8x32_t a, uint8x32_t b)
+        /// 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_s16 (int16x16_t value, int16x16_t shift)
+        /// 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_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u64 (uint64x4_t value, uint64x4_t shift)
+        /// 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 xvadda_b_s8 (int8x32_t a)
-        ///   LASX: XVADDA.B Xd.32B, Xd.32B, 0
+        /// 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 xvadda_h_s16 (int16x16_t a)
-        ///   LASX: XVADDA.H Xd.16H, Xd.16H, 0
+        /// 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 xvadda_w_s32 (int32x8_t a)
-        ///   LASX: XVADDA.W Xd.8S, Xd.8S, 0
+        /// 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 xvadda_d_s64 (int64xx_t a)
-        ///   LASX: XVADDA.D Xd.4D, Xd.4D, 0
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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 xvfsqrt_s_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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 xvfrintrm_s_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_f32 (float32x8_t a)
+        /// 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_f64 (float64x4_t a)
+        /// 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_s8 (int8_t a, int8x32_t v, const int imm)
-        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// 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, byte index, sbyte data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8_t a, uint8x32_t v, const int imm)
-        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// 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 index, byte data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int16x16_t TODO_s16 (int16_t a, int16x16_t v, const int imm)
-        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// 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, byte index, short data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16_t a, uint16x16_t v, const int imm)
-        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// 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, byte index, ushort data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int32x8_t xvinsgr2vr_w_s32 (int32_t a, int32x8_t v, const int imm)
-        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// 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, byte index, int data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint32x8_t xvinsgr2vr_w_u32 (uint32_t a, uint32x8_t v, const int imm)
-        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// 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, byte index, uint data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int64x4_t xvinsgr2vr_d_s64 (int64_t a, int64x4_t v, const int imm)
-        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// 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, byte index, long data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint64x4_t xvinsgr2vr_d_u64 (uint64_t a, uint64x4_t v, const int imm)
-        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// 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, byte index, ulong data) => Insert(vector, index, data);
 
         /// <summary>
-        /// float32x8_t xvinsve0_w_f32 (float32_t a, float32x8_t v, const int imm)
-        ///   LASX: XVINSVE0.W Xd.S[imm], Xj.S[0], imm
+        /// 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, byte index, float data) => Insert(vector, index, data);
 
         /// <summary>
-        /// float64x4_t xvinsve0_d_f64 (float64_t a, float64x4_t v, const int imm)
-        ///   LASX: XVINSVE0.D Xd.D[imm], Xj.D[0], imm
+        /// 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, byte index, double data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int8x32_t xvreplgr2vr_b_s8 (int8_t value)
+        /// 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_u8 (uint8_t value)
+        /// 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_s16 (int16_t value)
+        /// 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_u16 (uint16_t value)
+        /// 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_s32 (int32_t value)
-        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// 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_u32 (uint32_t value)
-        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// 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_s64 (int64_t value)
+        /// 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_u64 (uint64_t value)
+        /// 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_f32 (float32_t value)
+        /// 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_f64 (float64_t value)
+        /// 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_f32_s32 (int32x8_t a)
-        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8S
+        /// 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_f32_u32 (uint32x8_t a)
-        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8S
+        /// 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_f64_s64 (int64x4_t a)
+        /// 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_f64_u64 (uint64x4_t a)
+        /// 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_u8 (uint8x32_t value)
+        /// 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_u8 (uint8x32_t value)
+        /// 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_s8 (int8x32_t value)
+        /// 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_u8 (uint8x32_t value)
+        /// 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_s16 (int16x16_t value)
+        /// 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_u16 (uint16x16_t value)
+        /// 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_s32 (int32x8_t value)
+        /// 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_u32 (uint32x8_t value)
+        /// 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_s64 (int64x8_t value)
+        /// 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_u64 (uint64x8_t value)
+        /// 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_s8 (int8x32_t value)
+        /// 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_u8 (uint8x32_t value)
+        /// 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_s16 (int16x16_t value)
+        /// 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_u16 (uint16x16_t value)
+        /// 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_s32 (int32x8_t value)
+        /// 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_u32 (uint32x8_t value)
+        /// 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_s64 (int64x8_t value)
+        /// 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_u64 (uint64x8_t value)
+        /// 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_s16 (int16x16_t left, int16x16_t right, shift)
+        /// 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_u16 (uint16x16_t left, uint16x16_t right, shift)
+        /// 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_s32 (int32x8_t left, int32x8_t right, shift)
+        /// 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_u32 (uint32x8_t left, uint32x8_t right, shift)
+        /// 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_s64 (int64x4_t left, int64x4_t right, shift)
+        /// 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_u64 (uint64x4_t left, uint64x4_t right, shift)
+        /// 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);
@@ -3367,31 +3715,31 @@ internal Lasx() { }
         //public static Vector256<ulong> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// uint8x16_t xvsrln_b_h_u16 (uint16x16_t value, uint16x16_t shift)
+        /// 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_s32 (int32x8_t value, int32x8_t shift)
+        /// 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_u32 (uint32x8_t value, uint32x8_t shift)
+        /// 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_s64 (int64x4_t value, int64x4_t shift)
+        /// 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_u64 (uint64x4_t value, uint64x4_t shift)
+        /// 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);
@@ -3877,97 +4225,97 @@ internal Lasx() { }
         public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) => LeadingZeroCount(value);
 
         /// <summary>
-        /// int8x32_t xvpcnt_b_s8 (int8x32_t a)
+        /// 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_u8 (uint8x32_t a)
+        /// 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_s16 (int16x16_t a)
+        /// 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_u16 (uint16x16_t a)
+        /// 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_s32 (int32x8_t a)
+        /// 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_u32 (uint32x8_t a)
+        /// 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_s64 (int64x4_t a)
+        /// 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_u64 (uint64x4_t a)
+        /// uint64x4_t xvpcnt_d(uint64x4_t a)
         ///   LASX: XVPCNT_D Xd, Xj
         /// </summary>
         public static Vector256<ulong> PopCount(Vector256<ulong> value) => PopCount(value);
 
         /// <summary>
-        ///  uint8x32_t xvrepl128vei_u8(uint8x32_t vector, uint8_t idx)
+        ///  uint8x32_t xvrepl128vei(uint8x32_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
         /// </summary>
         public static Vector256<byte> VectorElementReplicate(Vector256<byte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  int8x32_t xvrepl128vei_s8(int8x32_t vector, uint8_t idx)
+        ///  int8x32_t xvrepl128vei(int8x32_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
         /// </summary>
         public static Vector256<sbyte> VectorElementReplicate(Vector256<sbyte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  int16x16_t xvrepl128vei_s16(int16x16_t vector, uint8_t idx)
+        ///  int16x16_t xvrepl128vei(int16x16_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
         /// </summary>
         public static Vector256<short> VectorElementReplicate(Vector256<short> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  uint16x16_t xvrepl128vei_u16(uint16x16_t vector, uint8_t idx)
+        ///  uint16x16_t xvrepl128vei(uint16x16_t vector, uint8_t idx)
         ///   LASX: XVREPLVEI_H Xd.16H, Xj.16H, ui3
         /// </summary>
         public static Vector256<ushort> VectorElementReplicate(Vector256<ushort> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  int32x8_t xvrepl128vei_s32(int32x8_t vector, uint8_t idx)
+        ///  int32x8_t xvrepl128vei(int32x8_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
         /// </summary>
         public static Vector256<int> VectorElementReplicate(Vector256<int> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  uint32x8_t xvrepl128vei_u32(uint32x8_t vector, uint8_t idx)
+        ///  uint32x8_t xvrepl128vei(uint32x8_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
         /// </summary>
         public static Vector256<uint> VectorElementReplicate(Vector256<uint> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  int64x4_t xvrepl128vei_s64(int64x4_t vector, uint8_t idx)
+        ///  int64x4_t xvrepl128vei(int64x4_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
         /// </summary>
         public static Vector256<long> VectorElementReplicate(Vector256<long> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
 
         /// <summary>
-        ///  uint64x4_t xvrepl128vei_u64(uint64x4_t vector, uint8_t idx)
+        ///  uint64x4_t xvrepl128vei(uint64x4_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
         /// </summary>
         public static Vector256<ulong> VectorElementReplicate(Vector256<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
@@ -3998,13 +4346,13 @@ internal Lasx() { }
 
         /// <summary>
         /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
-        ///   LASX: XVBITCLRI.W Xd.4S, Xj.4S, ui5
+        ///   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.4S, Xj.4S, ui5
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
         /// </summary>
         public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, const byte index) => VectorElementBitClear(value, index);
 
@@ -4094,13 +4442,13 @@ internal Lasx() { }
 
         /// <summary>
         /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
-        ///   LASX: XVBITSETI.W Xd.4S, Xj.4S, ui5
+        ///   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.4S, Xj.4S, ui5
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
         /// </summary>
         public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, const byte index) => VectorElementBitSet(value, index);
 
@@ -4190,13 +4538,13 @@ internal Lasx() { }
 
         /// <summary>
         /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
-        ///   LASX: XVBITREVI.W Xd.4S, Xj.4S, ui5
+        ///   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.4S, Xj.4S, ui5
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
         /// </summary>
         public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, const byte index) => VectorElementBitRevert(value, index);
 
@@ -4260,6 +4608,6 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index) => VectorElementBitRevert(value, index);
 
-        // TODO:----------------------------------
+        // TODO:----------------------------------VectorShuffle
     }
 }
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
index 31bc2dc9d12a06..65faa9a0979660 100644
--- 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
@@ -17,3541 +17,3943 @@ internal Lsx() { }
         public static new bool IsSupported { get => IsSupported; }
 
         /// <summary>
-        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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 TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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 TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VADD.W Vd.4S, Vj.4S, Vk.4S
+        /// 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 TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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 TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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>
-        /// int8x16_t vsub_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// int8x8_t vsadd_b(int8x8_t a, uint8x8_t b)
+        ///   LSX: VSADD.B Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) => Subtract(left, right);
+        public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint8x8_t vsadd_bu(uint8x8_t a, int8x8_t b)
+        ///   LSX: VSADD.BU Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) => Subtract(left, right);
+        public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int16x8_t vsub_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// int16x4_t vsadd_h(int16x4_t a, uint16x4_t b)
+        ///   LSX: VSADD.H Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) => Subtract(left, right);
+        public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint16x4_t vsadd_hu(uint16x4_t a, int16x4_t b)
+        ///   LSX: VSADD.HU Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) => Subtract(left, right);
+        public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int32x4_t vsub_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// int32x2_t vsadd_w(int32x2_t a, uint32x2_t b)
+        ///   LSX: VSADD.W Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) => Subtract(left, right);
+        public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// uint32x2_t vsadd_wu(uint32x2_t a, int32x2_t b)
+        ///   LSX: VSADD.WU Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) => Subtract(left, right);
+        public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int64x2_t vsub_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// int64x1_t vsadd_d(int64x1_t a, uint64x1_t b)
+        ///   LSX: VSADD.D Vd.D, Vj.D
         /// </summary>
-        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) => Subtract(left, right);
+        public static Vector64<long> AddSaturate(Vector64<long> left, Vector64<ulong> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint64x1_t vsadd_du(uint64x1_t a, int64x1_t b)
+        ///   LSX: VSADD.DU Vd.D, Vj.D
         /// </summary>
-        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) => Subtract(left, right);
+        public static Vector64<ulong> AddSaturate(Vector64<ulong> left, Vector64<long> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// float32x4_t vfsub_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// int8x16_t vsadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) => Subtract(left, right);
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// float64x2_t vfsub_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vsadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) => Subtract(left, right);
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int8x16_t vmul_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vsadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) => Multiply(left, right);
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint8x16_t vmul_b_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vsadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) => Multiply(left, right);
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int16x8_t vmul_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// uint8x16_t vsadd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) => Multiply(left, right);
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint16x8_t vmul_h_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// uint16x8_t vsadd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) => Multiply(left, right);
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int32x4_t vmul_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// uint32x4_t vsadd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) => Multiply(left, right);
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// uint32x4_t vmul_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// uint64x2_t vsadd_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) => Multiply(left, right);
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) => AddSaturate(left, right);
 
         /// <summary>
-        /// int64x2_t vmul_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> Multiply(Vector128<long> left, Vector128<long> right) => Multiply(left, right);
+        public static Vector128<short> AddOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint64x2_t vmul_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) => Multiply(left, right);
+        public static Vector128<ushort> AddOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// float32x4_t vfmul_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> Multiply(Vector128<float> left, Vector128<float> right) => Multiply(left, right);
+        public static Vector128<int> AddOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// float64x2_t vfmul_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
+        public static Vector128<uint> AddOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int8x16_t vmuh_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMUH.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyHight(left, right);
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint8x16_t vmuh_b_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMUH.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right) => MultiplyHight(left, right);
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int16x8_t vmuh_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMUH.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<short> MultiplyHight(Vector128<short> left, Vector128<short> right) => MultiplyHight(left, right);
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint16x8_t vmuh_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMUH.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right) => MultiplyHight(left, right);
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddOddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int32x4_t vmuh_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// 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<int> MultiplyHight(Vector128<int> left, Vector128<int> right) => MultiplyHight(left, right);
+        public static Vector128<short> AddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint32x4_t vmuh_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMUH.WU Vd.4W, Vj.4W, Vk.4W
+        /// 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<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right) => MultiplyHight(left, right);
+        public static Vector128<ushort> AddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int64x2_t vmuh_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMUH.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> MultiplyHight(Vector128<long> left, Vector128<long> right) => MultiplyHight(left, right);
+        public static Vector128<int> AddEvenElementsWidening(Vector128<short> left, Vector128<short> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint64x2_t vmuh_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMUH.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right) => MultiplyHight(left, right);
+        public static Vector128<uint> AddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int8x16_t vdiv_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right) => Divide(left, right);
+        public static Vector128<long> AddEvenElementsWidening(Vector128<int> left, Vector128<int> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint8x16_t vdiv_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VDIV.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> Divide(Vector128<byte> left, Vector128<byte> right) => Divide(left, right);
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int16x8_t vdiv_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VDIV.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<short> Divide(Vector128<short> left, Vector128<short> right) => Divide(left, right);
+        public static Vector128<long> AddEvenElementsWidening(Vector128<long> left, Vector128<long> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint16x8_t vdiv_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VDIV.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right) => Divide(left, right);
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int32x4_t vdiv_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VDIV.W Vd.4W, Vj.4W, Vk.4W
+        /// 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<int> Divide(Vector128<int> left, Vector128<int> right) => Divide(left, right);
+        public static Vector128<short> AddOddElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// uint32x4_t vdiv_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VDIV.WU Vd.4W, Vj.4W, Vk.4W
+        /// 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<uint> Divide(Vector128<uint> left, Vector128<uint> right) => Divide(left, right);
+        public static Vector128<ushort> AddOddElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// int64x2_t vdiv_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> Divide(Vector128<long> left, Vector128<long> right) => Divide(left, right);
+        public static Vector128<int> AddOddElementsWidening(Vector128<short> left, Vector128<short> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// uint64x2_t vdiv_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VDIV.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right) => Divide(left, right);
+        public static Vector128<uint> AddOddElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// float32x4_t vfdiv_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFDIV.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> Divide(Vector128<float> left, Vector128<float> right) => Divide(left, right);
+        public static Vector128<long> AddOddElementsWidening(Vector128<int> left, Vector128<int> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// float64x2_t vfdiv_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// int8x16_t vmod_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMOD.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> Modulo(Vector128<sbyte> left, Vector128<sbyte> right) => Modulo(left, right);
+        public static Vector128<long> AddOddElementsWidening(Vector128<long> left, Vector128<long> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// uint8x16_t vmod_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMOD.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> Modulo(Vector128<byte> left, Vector128<byte> right) => Modulo(left, right);
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// int16x8_t vmod_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMOD.H Vd.8H, Vj.8H, Vk.8H
+        /// 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> Modulo(Vector128<short> left, Vector128<short> right) => Modulo(left, right);
+        public static Vector128<short> AddEvenElementsWidening(Vector128<byte> left, Vector128<sbyte> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint16x8_t vmod_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMOD.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> Modulo(Vector128<ushort> left, Vector128<ushort> right) => Modulo(left, right);
+        public static Vector128<int> AddEvenElementsWidening(Vector128<ushort> left, Vector128<short> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int32x4_t vmod_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMOD.W Vd.4W, Vj.4W, Vk.4W
+        /// 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<int> Modulo(Vector128<int> left, Vector128<int> right) => Modulo(left, right);
+        public static Vector128<long> AddEvenElementsWidening(Vector128<uint> left, Vector128<int> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// uint32x4_t vmod_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMOD.WU Vd.4W, Vj.4W, Vk.4W
+        /// 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<uint> Modulo(Vector128<uint> left, Vector128<uint> right) => Modulo(left, right);
+        public static Vector128<long> AddEvenElementsWidening(Vector128<ulong> left, Vector128<long> right) => AddEvenElementsWidening(left, right);
 
         /// <summary>
-        /// int64x2_t vmod_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMOD.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> Modulo(Vector128<long> left, Vector128<long> right) => Modulo(left, right);
+        public static Vector128<short> AddOddElementsWidening(Vector128<byte> left, Vector128<sbyte> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// uint64x2_t vmod_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMOD.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> Modulo(Vector128<ulong> left, Vector128<ulong> right) => Modulo(left, right);
+        public static Vector128<int> AddOddElementsWidening(Vector128<ushort> left, Vector128<short> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// float32x4_t vfmadd_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) => FusedMultiplyAdd(addend, left, right);
+        public static Vector128<long> AddOddElementsWidening(Vector128<uint> left, Vector128<int> right) => AddOddElementsWidening(left, right);
 
         /// <summary>
-        /// float64x2_t vfmadd_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
-        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) => FusedMultiplyAdd(addend, left, right);
+        public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right) => AddOddElementsWidening(left, right);
+
+        //// 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) => 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>
-        /// int8x16_t vmadd_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
-        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vmul_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vmul(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) => Multiply(left, right);
 
         /// <summary>
-        /// int16x8_t vmadd_h_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// int64x2_t vmul_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint64x2_t vmul(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) => Multiply(left, right);
 
         /// <summary>
-        /// int32x4_t vmadd_w_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMADD.W Vd.4S, Vj.4S, Vk.4S
+        /// float32x4_t vfmul_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) => Multiply(left, right);
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// float64x2_t vfmul_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyAdd(addend, left, right);
+        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
 
         /// <summary>
-        /// int8x16_t TODO_s8 (int8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B
+        /// int8x16_t vmuh_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUH.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<byte> right) => AddSaturate(left, right);
+        public static Vector128<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, int8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B
+        /// uint8x16_t vmuh_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUH.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<sbyte> right) => AddSaturate(left, right);
+        public static Vector128<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// int16x8_t TODO_s16 (int16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H
+        /// int16x8_t vmuh_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUH.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<ushort> right) => AddSaturate(left, right);
+        public static Vector128<short> MultiplyHight(Vector128<short> left, Vector128<short> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, int16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H
+        /// uint16x8_t vmuh_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUH.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<short> right) => AddSaturate(left, right);
+        public static Vector128<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// int32x4_t TODO_s32 (int32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// int32x4_t vmuh_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<uint> right) => AddSaturate(left, right);
+        public static Vector128<int> MultiplyHight(Vector128<int> left, Vector128<int> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, int32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// uint32x4_t vmuh_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUH.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<int> right) => AddSaturate(left, right);
+        public static Vector128<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// int64x2_t TODO_s64 (int64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// int64x2_t vmuh_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUH.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<ulong> right) => AddSaturate(left, right);
+        public static Vector128<long> MultiplyHight(Vector128<long> left, Vector128<long> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, int64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// uint64x2_t vmuh_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUH.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<long> right) => AddSaturate(left, right);
+        public static Vector128<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right) => MultiplyHight(left, right);
 
         /// <summary>
-        /// int8x16_t vsadd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
+        /// int8x16_t vdiv_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => AddSaturate(left, right);
+        public static Vector128<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right) => Divide(left, right);
 
         /// <summary>
-        /// int16x8_t vsadd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
+        /// uint8x16_t vdiv_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VDIV.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) => AddSaturate(left, right);
+        public static Vector128<byte> Divide(Vector128<byte> left, Vector128<byte> right) => Divide(left, right);
 
         /// <summary>
-        /// int32x4_t vsadd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSADD.W Vd.4S, Vj.4S, Vk.4S
+        /// int16x8_t vdiv_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VDIV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) => AddSaturate(left, right);
+        public static Vector128<short> Divide(Vector128<short> left, Vector128<short> right) => Divide(left, right);
 
         /// <summary>
-        /// int64x2_t vsadd_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
+        /// uint16x8_t vdiv_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VDIV.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right) => AddSaturate(left, right);
+        public static Vector128<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right) => Divide(left, right);
 
         /// <summary>
-        /// uint8x16_t vsadd_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vdiv_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VDIV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) => AddSaturate(left, right);
+        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) => Divide(left, right);
 
         /// <summary>
-        /// uint16x8_t vsadd_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
+        /// uint32x4_t vdiv_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VDIV.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) => AddSaturate(left, right);
+        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) => Divide(left, right);
 
         /// <summary>
-        /// uint32x4_t vsadd_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSADD.WU Vd.4S, Vj.4S, Vk.4S
+        /// int64x2_t vdiv_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VDIV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) => AddSaturate(left, right);
+        public static Vector128<long> Divide(Vector128<long> left, Vector128<long> right) => Divide(left, right);
 
         /// <summary>
-        /// uint64x2_t vsadd_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
+        /// uint64x2_t vdiv_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VDIV.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) => AddSaturate(left, right);
+        public static Vector128<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right) => Divide(left, right);
 
         /// <summary>
-        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// float32x4_t vfdiv_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFDIV.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static Vector128<sbyte> HorizontalAdd(Vector128<sbyte> left, Vector128<sbyte> right) => HorizontalAdd(left, right);
+        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) => Divide(left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// float64x2_t vfdiv_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFDIV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> HorizontalAdd(Vector128<byte> left, Vector128<byte> right) => HorizontalAdd(left, right);
+        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
 
         /// <summary>
-        /// int16x8_t vadd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// int8x16_t vmod_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMOD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) => HorizontalAdd(left, right);
+        public static Vector128<sbyte> Modulo(Vector128<sbyte> left, Vector128<sbyte> right) => Modulo(left, right);
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// uint8x16_t vmod_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMOD.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ushort> HorizontalAdd(Vector128<ushort> left, Vector128<ushort> right) => HorizontalAdd(left, right);
+        public static Vector128<byte> Modulo(Vector128<byte> left, Vector128<byte> right) => Modulo(left, right);
 
         /// <summary>
-        /// int32x4_t vadd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// int16x8_t vmod_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMOD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) => HorizontalAdd(left, right);
+        public static Vector128<short> Modulo(Vector128<short> left, Vector128<short> right) => Modulo(left, right);
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        /// uint16x8_t vmod_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMOD.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<uint> HorizontalAdd(Vector128<uint> left, Vector128<uint> right) => HorizontalAdd(left, right);
+        public static Vector128<ushort> Modulo(Vector128<ushort> left, Vector128<ushort> right) => Modulo(left, right);
 
         /// <summary>
-        /// int64x2_t vadd_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// int32x4_t vmod_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMOD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> HorizontalAdd(Vector128<long> left, Vector128<long> right) => HorizontalAdd(left, right);
+        public static Vector128<int> Modulo(Vector128<int> left, Vector128<int> right) => Modulo(left, right);
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        /// uint32x4_t vmod_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMOD.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ulong> HorizontalAdd(Vector128<ulong> left, Vector128<ulong> right) => HorizontalAdd(left, right);
-
-        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
+        public static Vector128<uint> Modulo(Vector128<uint> left, Vector128<uint> right) => Modulo(left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
-        ///   LSX: Vector128.ToScalar
+        /// int64x2_t vmod_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMOD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static sbyte HorizontalSum(Vector128<sbyte> value) => HorizontalSum(value);
+        public static Vector128<long> Modulo(Vector128<long> left, Vector128<long> right) => Modulo(left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
-        ///   LSX: Vector128.ToScalar
+        /// uint64x2_t vmod_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMOD.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static byte HorizontalSum(Vector128<byte> value) => HorizontalSum(value);
+        public static Vector128<ulong> Modulo(Vector128<ulong> left, Vector128<ulong> right) => Modulo(left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
-        ///   LSX: Vector128.ToScalar
+        /// float32x4_t vfmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static short HorizontalSum(Vector128<short> value) => HorizontalSum(value);
+        public static Vector128<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) => FusedMultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
-        ///   LSX: Vector128.ToScalar
+        /// float64x2_t vfmadd_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static ushort HorizontalSum(Vector128<ushort> value) => HorizontalSum(value);
+        public static Vector128<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) => FusedMultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
-        ///   LSX: Vector128.ToScalar
+        /// int8x16_t vmadd_b(int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static int HorizontalSum(Vector128<int> value) => HorizontalSum(value);
+        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
-        ///   LSX: Vector128.ToScalar
+        /// 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 uint HorizontalSum(Vector128<uint> value) => HorizontalSum(value);
+        public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
-        ///   LSX: Vector128.ToScalar
+        /// 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 long HorizontalSum(Vector128<long> value) => HorizontalSum(value);
+        public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
-        ///   LSX: Vector128.ToScalar
+        /// 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 ulong HorizontalSum(Vector128<ulong> value) => HorizontalSum(value);
+        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: sum_all_float_elements witin value.
-        ///   LSX: Vector128.ToScalar
+        /// 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 float HorizontalSum(Vector128<float> value) => HorizontalSum(value);
+        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: sum_all_double_elements witin value.
-        ///   LSX: Vector128.ToScalar
+        /// 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 double HorizontalSum(Vector128<double> value) => HorizontalSum(value);
+        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyAdd(addend, left, right);
 
         /// <summary>
-        /// int8x16_t vmsub_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
+        /// int8x16_t vmsub_b(int8x16_t a, int8x16_t b, int8x16_t c)
         ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
         public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        /// uint8x16_t TODO(uint8x16_t a, uint8x16_t b, uint8x16_t c)
         ///   LSX: TODO 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_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
+        /// 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 TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        /// uint16x8_t TODO(uint16x8_t a, uint16x8_t b, uint16x8_t c)
         ///   LSX: TODO 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_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// 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 TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// 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>
-        /// int16x8_t vmaddwev_h_b_s8 (int16x8_t a, int8x8_t b, int8x8_t c)
+        /// 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_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c)
+        /// 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_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
-        ///   LSX: VMADDWEV.W.H Vd.4S, Vj.4H, Vk.4H
+        /// 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_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
-        ///   LSX: VMADDWEV.W.HU Vd.4S, Vj.4H, Vk.4H
+        /// 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_s32 (int64x2_t a, int32x2_t b, int32x2_t c)
+        /// 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_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c)
+        /// 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_s8 (int16x8_t a, int8x16_t b, int8x16_t c)
+        /// 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_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c)
+        /// 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_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VMADDWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// 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_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: VMADDWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// 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_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// 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_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// 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>
-        /// uint8x16_t vseq_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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))] const 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))] const 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))] const 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))] const 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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>
-        /// uint16x8_t vseq_h_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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>
-        /// uint32x4_t vseq_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// 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>
-        /// uint64x2_t vseq_d_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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>
-        /// uint32x4_t vfcmp_ceq_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CEQ.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
+        public static Vector128<int> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
 
         /// <summary>
-        /// uint64x2_t vfcmp_ceq_d_f64 (float64x2_t a, float64x2_t b)
+        /// 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<double> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
+        public static Vector128<long> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
+
+        /// <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))] const 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))] const 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))] const sbyte si5) => CompareLessThan(value, si5);
 
         /// <summary>
-        /// uint8x16_t vslt_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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))] const 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_s8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_s16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_s32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_s64 (uint64x2_t a, uint64x2_t b)
+        /// 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>
-        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
+        public static Vector128<int> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
 
         /// <summary>
-        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        /// 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<double> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
+        public static Vector128<long> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
 
         /// <summary>
-        /// uint8x16_t vsle_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// 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> left, Vector128<sbyte> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint8x16_t vsle_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// int16x8_t vslei_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSLEI.H Vd.8H, Vj.8H, si5
         /// </summary>
-        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint16x8_t vsle_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// int32x4_t vslei_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSLEI.W Vd.4W, Vj.4W, si5
         /// </summary>
-        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint16x8_t vsle_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// int64x2_t vslei_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSLEI.D Vd.2D, Vj.2D, si5
         /// </summary>
-        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value,  [ConstantExpected(Min = -16, Max = (byte)(15))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
 
         /// <summary>
-        /// uint32x4_t vsle_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// uint8x16_t vsle_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) => CompareLessThanOrEqual(left, right);
+        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_s64 (int64x2_t a, int64x2_t b)
+        /// 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>
-        /// uint64x2_t vsle_du_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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(Min = 0, Max = (byte)(31))] const 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>
-        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        /// 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<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
 
         /// <summary>
-        /// uint8x16_t vsle_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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>
-        /// uint8x16_t vsle_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThan(left, right);
+        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint16x8_t vsle_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// uint32x4_t vsle_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) => CompareGreaterThan(left, right);
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint16x8_t vsle_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// uint64x2_t vsle_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThan(left, right);
+        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint32x4_t vsle_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) => CompareGreaterThan(left, right);
+        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// uint16x8_t vsle_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThan(left, right);
+        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint64x2_t vsle_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// uint32x4_t vsle_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) => CompareGreaterThan(left, right);
+        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint64x2_t vsle_du_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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>
-        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
+        public static Vector128<int> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
+        /// 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<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
+        public static Vector128<long> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
 
         /// <summary>
-        /// uint8x16_t vslt_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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>
-        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
 
         /// <summary>
-        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
+        /// 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<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
+        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
 
         /// <summary>
-        /// int8x16_t vmax_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMAX.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMAX.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMAX.D Vd.4S, Vj.4S, Vk.4S
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMAX.DU Vd.4S, Vj.4S, Vk.4S
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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>
-        /// int8x16_t vmin_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMIN.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMIN.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMIN.D Vd.4S, Vj.4S, Vk.4S
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMIN.DU Vd.4S, Vj.4S, Vk.4S
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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>
-        /// int8x16_t vbitsel_v_s8 (uint8x16_t a, int8x16_t b, int8x16_t c)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        /// 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_s16 (uint16x8_t a, int16x8_t b, int16x8_t c)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        /// 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_s32 (uint32x4_t a, int32x4_t b, int32x4_t c)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        /// 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_s64 (uint64x2_t a, int64x2_t b, int64x2_t c)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        /// 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_f32 (uint32x4_t a, float32x4_t b, float32x4_t c)
+        /// 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_f64 (uint64x2_t a, float64x2_t b, float64x2_t c)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VABSD.W Vd.4S, Vj.4S, Vk.4S
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VABSD.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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_s64 (uint64x2_t a, int64x2_t b, int64x2_t c)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
-        /// </summary>
-        public static Vector128<float> AbsoluteDifference(Vector128<float> left, Vector128<float> 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_f64 (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>
+        ///// 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_s8 (int8_t const * ptr)
+        /// int8x16_t vld(int8_t const * ptr)
         ///   LSX: VLD Vd.16B, Rj, si12
         /// </summary>
         public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) => LoadVector128(address);
 
         /// <summary>
-        /// uint8x16_t vld_u8 (uint8_t const * ptr)
+        /// uint8x16_t vld(uint8_t const * ptr)
         ///   LSX: VLD Vd.16B, Rj, si12
         /// </summary>
         public static unsafe Vector128<byte> LoadVector128(byte* address) => LoadVector128(address);
 
         /// <summary>
-        /// int16x8_t vld_s16 (int16_t const * ptr)
+        /// int16x8_t vld(int16_t const * ptr)
         ///   LSX: VLD Vd.8H, Rj, si12
         /// </summary>
         public static unsafe Vector128<short> LoadVector128(short* address) => LoadVector128(address);
 
         /// <summary>
-        /// uint16x8_t vld_s16 (uint16_t const * ptr)
+        /// uint16x8_t vld(uint16_t const * ptr)
         ///   LSX: VLD Vd.8H, Rj, si12
         /// </summary>
         public static unsafe Vector128<ushort> LoadVector128(ushort* address) => LoadVector128(address);
 
         /// <summary>
-        /// int32x4_t vld_s32 (int32_t const * ptr)
-        ///   LSX: VLD Vd.4S, Rj, si12
+        /// int32x4_t vld(int32_t const * ptr)
+        ///   LSX: VLD Vd.4W, Rj, si12
         /// </summary>
         public static unsafe Vector128<int> LoadVector128(int* address) => LoadVector128(address);
 
         /// <summary>
-        /// uint32x4_t vld_s32 (uint32_t const * ptr)
-        ///   LSX: VLD Vd.4S, Rj, si12
+        /// uint32x4_t vld(uint32_t const * ptr)
+        ///   LSX: VLD Vd.4W, Rj, si12
         /// </summary>
         public static unsafe Vector128<uint> LoadVector128(uint* address) => LoadVector128(address);
 
         /// <summary>
-        /// int64x2_t vld_s64 (int64_t const * ptr)
+        /// int64x2_t vld(int64_t const * ptr)
         ///   LSX: VLD Vd.2D, Rj, si12
         /// </summary>
         public static unsafe Vector128<long> LoadVector128(long* address) => LoadVector128(address);
 
         /// <summary>
-        /// uint64x2_t vld_u64 (uint64_t const * ptr)
+        /// uint64x2_t vld(uint64_t const * ptr)
         ///   LSX: VLD Vd.2D, Rj, si12
         /// </summary>
         public static unsafe Vector128<ulong> LoadVector128(ulong* address) => LoadVector128(address);
 
         /// <summary>
-        /// float32x4_t vld_f32 (float32_t const * ptr)
+        /// float32x4_t vld(float32_t const * ptr)
         ///   LSX: VLD Vd.4S, Rj, si12
         /// </summary>
         public static unsafe Vector128<float> LoadVector128(float* address) => LoadVector128(address);
 
         /// <summary>
-        /// float64x2_t vld_f64 (float64_t const * ptr)
+        /// float64x2_t vld(float64_t const * ptr)
         ///   LSX: VLD Vd.2D, Rj, si12
         /// </summary>
         public static unsafe Vector128<double> LoadVector128(double* address) => LoadVector128(address);
 
         /// <summary>
-        /// float32x4_t vfrecip_s_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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>
-        /// void vst_s8 (int8_t * ptr, int8x16_t val)
-        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// void vst(int8_t * ptr, int8x16_t val)
+        ///   LSX: VST Vd.16B, Rj, si12
         /// </summary>
         public static unsafe void Store(sbyte* address, Vector128<sbyte> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_u8 (uint8_t * ptr, uint8x16_t val)
-        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// void vst(uint8_t * ptr, uint8x16_t val)
+        ///   LSX: VST Vd.16B, Rj, si12
         /// </summary>
         public static unsafe void Store(byte* address, Vector128<byte> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_s16 (int16_t * ptr, int16x8_t val)
-        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// void vst(int16_t * ptr, int16x8_t val)
+        ///   LSX: VST Vd.8H, Rj, si12
         /// </summary>
         public static unsafe void Store(short* address, Vector128<short> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_u16 (uint16_t * ptr, uint16x8_t val)
-        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// void vst(uint16_t * ptr, uint16x8_t val)
+        ///   LSX: VST Vd.8H, Rj, si12
         /// </summary>
         public static unsafe void Store(ushort* address, Vector128<ushort> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_s32 (int32_t * ptr, int32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// void vst(int32_t * ptr, int32x4_t val)
+        ///   LSX: VST Vd.4W, Rj, si12
         /// </summary>
         public static unsafe void Store(int* address, Vector128<int> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_u32 (uint32_t * ptr, uint32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// void vst(uint32_t * ptr, uint32x4_t val)
+        ///   LSX: VST Vd.4W, Rj, si12
         /// </summary>
         public static unsafe void Store(uint* address, Vector128<uint> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_s64 (int64_t * ptr, int64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// void vst(int64_t * ptr, int64x2_t val)
+        ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
         public static unsafe void Store(long* address, Vector128<long> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_u64 (uint64_t * ptr, uint64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// void vst(uint64_t * ptr, uint64x2_t val)
+        ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
         public static unsafe void Store(ulong* address, Vector128<ulong> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_f32 (float32_t * ptr, float32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// void vst(float32_t * ptr, float32x4_t val)
+        ///   LSX: VST Vd.4S, Rj, si12
         /// </summary>
         public static unsafe void Store(float* address, Vector128<float> source) => Store(address, source);
 
         /// <summary>
-        /// void vst_f64 (float64_t * ptr, float64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// void vst(float64_t * ptr, float64x2_t val)
+        ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
         public static unsafe void Store(double* address, Vector128<double> source) => Store(address, source);
 
         /// <summary>
-        /// int8x16_t vneg_b_s8 (int8x16_t a)
+        /// 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_s16 (int16x8_t a)
+        /// 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_s32 (int32x4_t a)
-        ///   LSX: VNEG.W Vd.4S, Vj.4S
+        /// 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_s64 (int64x2_t a)
+        /// 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 TODO_f32 (float32x4_t a)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// 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 TODO_f64 (float64x2_t a)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// 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_f64 (float64x1_t a)
+        /// 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_f32 (float32_t a)
+        /// float32_t fneg_s(float32_t a)
         ///   LSX: FNEG.S Fd, Fj
         /// </summary>
         public static Vector64<float> NegateScalar(Vector64<float> value) => NegateScalar(value);
 
         /// <summary>
-        /// float32x4_t vfmsub_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
+        /// float32x4_t vfmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
         ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
         public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right) => FusedMultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// float64x2_t vfmsub_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
+        /// float64x2_t vfmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
         ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
         public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right) => FusedMultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// int16x8_t vmulwod_h_b_s8 (int8x16_t a, int8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_s8 (uint8x16_t a, int8x16_t b)
+        /// 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_s16 (uint16x8_t a, int16x8_t b)
+        /// 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_s32 (uint32x4_t a, int32x4_t b)
+        /// 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_s64 (uint64x2_t a, int64x2_t b)
+        /// 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_s8 (uint8x16_t a, int8x16_t b)
+        /// 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) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// int32x4_t vmulwev_w_hu_s16 (uint16x8_t a, int16x8_t b)
+        /// 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) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// int64x2_t vmulwev_d_wu_s32 (uint32x4_t a, int32x4_t b)
+        /// 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) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// int128x1_t vmulwev_q_du_s64 (uint64x2_t a, int64x2_t b)
+        /// 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) => MultiplyWideningEven(left, right);
 
         /// <summary>
-        /// int8x16_t vssub_b_s8(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_u8(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_s16(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_u16(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_s32(int32x4_t a, int32x4_t b)
-        ///   LSX: VSSUB.W Vd.4S, Vj.4S, Vk.4S
-        /// </summary>
-        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) => SubtractSaturate(left, right);
-
-        /// <summary>
-        /// uint32x4_t vssub_wu_u32(uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSSUB.WU Vd.4S, Vj.4S, Vk.4S
-        /// </summary>
-        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) => SubtractSaturate(left, right);
-
-        /// <summary>
-        /// int64x2_t vssub_d_s64(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_u64(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 vavg_b_s8(int8x16_t a, int8x16_t b)
+        /// 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_u8(uint8x16_t a, uint8x16_t b)
+        /// 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_s16(int16x8_t a, int16x8_t b)
+        /// 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_u16(uint16x8_t a, uint16x8_t b)
+        /// 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_s32(int32x4_t a, int32x4_t b)
+        /// 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_u32(uint32x4_t a, uint32x4_t b)
+        /// 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_s64(int64x2_t a, int64x2_t b)
+        /// 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_u64(uint64x2_t a, uint64x2_t b)
+        /// 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);
 
+
+        ////qiaoqiao. TODO.
+        public static Vector128<ulong> AverageRounded(Vector128<ulong> left, Vector128<ulong> right) => Average(left, right);
+
         /// <summary>
-        /// int16x8_t vsllwil_h_b_s8(int8x16_t a, uint8_t ui3)
+        /// 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_s16(int16x4_t a, uint8_t ui4)
+        /// 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_s32(int32x2_t a, uint8_t ui5)
+        /// 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_u8(uint8x16_t a, uint8_t ui3)
+        /// 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_s8(int8x16_t a, uint8_t ui3)
+        /// 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_u16(uint16x8_t a, uint8_t ui4)
+        /// 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_s16(int16x8_t a, uint8_t ui4)
+        /// 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_u32(uint32x4_t a, uint8_t ui5)
+        /// 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_s32(int32x4_t a, uint8_t ui5)
+        /// 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_s64(int64_t a)
+        /// 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_u64(uint64_t a)
+        /// 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_s8(int8x16_t a)
+        /// 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_s16(int16x8_t a)
+        /// 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_s32(int32x4_t a)
+        /// 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_s64(int64x2_t a)
+        /// 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_s8(int8x16_t a)
+        /// 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_u8(uint8x16_t a)
+        /// 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_s16(int16x8_t a)
+        /// 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_u16(uint16x8_t a)
+        /// 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_s32(uint32x4_t a)
+        /// 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_u32(uint32x4_t a)
+        /// 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_s64(int64x2_t a)
+        /// 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_u64(uint64x2_t a)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_u8 (uint8x8_t a, uint8x8_t b)
+        /// 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_f64 (float64x1_t a, float64x1_t b)
+        /// 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_s16 (int16x4_t a, int16x4_t b)
+        /// 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_s32 (int32x2_t a, int32x2_t b)
+        /// 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_s64 (int64x1_t a, int64x1_t b)
+        /// 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_s8 (int8x8_t a, int8x8_t b)
+        /// 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_f32 (float32x2_t a, float32x2_t b)
+        /// 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_u16 (uint16x4_t a, uint16x4_t b)
+        /// 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_u32 (uint32x2_t a, uint32x2_t b)
+        /// 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_u64 (uint64x1_t a, uint64x1_t b)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_u8 (uint8x8_t a)
+        /// 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_f64 (float64x1_t a)
+        /// 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_s16 (int16x4_t a)
+        /// 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_s32 (int32x2_t a)
+        /// 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_s64 (int64x1_t a)
+        /// 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_s8 (int8x8_t a)
+        /// 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_f32 (float32x2_t a)
+        /// 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_u16 (uint16x4_t a)
+        /// 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_u32 (uint32x2_t a)
+        /// 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_u64 (uint64x1_t a)
+        /// 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_u8 (uint8x16_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_s16 (int16x8_t a)
+        /// 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_s32 (int32x4_t a)
+        /// 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_s64 (int64x2_t a)
+        /// 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_s8 (int8x16_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_u16 (uint16x8_t a)
+        /// 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_u32 (uint32x4_t a)
+        /// 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_u64 (uint64x2_t a)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_u8 (uint8x8_t a, uint8x8_t b)
+        /// 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_f64 (float64x1_t a, float64x1_t b)
+        /// 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_s16 (int16x4_t a, int16x4_t b)
+        /// 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_s32 (int32x2_t a, int32x2_t b)
+        /// 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_s64 (int64x1_t a, int64x1_t b)
+        /// 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_s8 (int8x8_t a, int8x8_t b)
+        /// 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_f32 (float32x2_t a, float32x2_t b)
+        /// 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_u16 (uint16x4_t a, uint16x4_t b)
+        /// 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_u32 (uint32x2_t a, uint32x2_t b)
+        /// 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_u64 (uint64x1_t a, uint64x1_t b)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_u8 (uint8x8_t a, uint8x8_t b)
+        /// 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_f64 (float64x1_t a, float64x1_t b)
+        /// 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_s16 (int16x4_t a, int16x4_t b)
+        /// 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_s32 (int32x2_t a, int32x2_t b)
+        /// 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_s64 (int64x1_t a, int64x1_t b)
+        /// 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_s8 (int8x8_t a, int8x8_t b)
+        /// 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_f32 (float32x2_t a, float32x2_t b)
+        /// 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_u16 (uint16x4_t a, uint16x4_t b)
+        /// 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_u32 (uint32x2_t a, uint32x2_t b)
+        /// 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_u64 (uint64x1_t a, uint64x1_t b)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t a, int16x8_t b)
+        /// 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_u16 (uint16x8_t a, uint16x8_t b)
+        /// 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_s32 (int32x4_t a, int32x4_t b)
+        /// 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_u32 (uint32x4_t a, uint32x4_t b)
+        /// 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_s64 (int64x2_t a, int64x2_t b)
+        /// 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_u64 (uint64x2_t a, uint64x2_t b)
+        /// 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_f32 (float32x4_t a, float32x4_t b)
+        /// 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_f64 (float64x2_t a, float64x2_t b)
+        /// 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_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        /// int8x16_t vslli_b(int8x16_t a, const int n) //qiaoqiao.ok.
         ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
         /// </summary>
         public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint8x16_t vslli_b_u8 (uint8x16_t a, const int n)
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// int16x8_t vslli_h_s16 (int16x8_t a, const int n)
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint16x8_t vslli_h_u16 (uint16x8_t a, const int n)
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint32x4_t vslli_w_s32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, ui5
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint32x4_t vslli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, ui5
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// int64x2_t vslli_d_s64 (int64x2_t a, const int n)
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// uint64x2_t vslli_d_u64 (uint64x2_t a, const int n)
+        /// 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 const byte shift) => ShiftLeftLogical(value, shift);
 
         /// <summary>
-        /// int8x16_t vsll_b_u8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_s16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_s32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u64 (uint64x2_t value, uint64x2_t shift)
+        /// 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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        /// uint8x16_t vsrli_b(uint8x16_t a, const int n) //qiaoqiao.ok.
         ///   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_u8 (uint8x16_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, ui5
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, ui5
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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 vsrl_b_u8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_s16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_s32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u64 (uint64x2_t value, uint64x2_t shift)
+        /// 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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        /// uint8x16_t vsrlri_b(uint8x16_t a, const int n) //qiaoqiao.ok.
         ///   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_u8 (uint8x16_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, ui5
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, ui5
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_u16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_u32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u64 (uint64x2_t value, uint64x2_t shift)
+        /// 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_u16 (uint16x8_t left, uint16x8_t right, const int n)  qiaoqiao.ok.
+        /// uint8x16_t vsrlrni_b_h(uint16x8_t left, uint16x8_t right, const int n)  qiaoqiao.ok.
         ///   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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int8x16_t vsrlrni_b_h_s16 (int16x8_t left, int16x8_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int16x8_t vsrlrni_h_w_s32 (int32x4_t left, int32x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// uint16x8_t vsrlrni_h_w_u32 (uint32x4_t left, uint32x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int32x4_t vsrlrni_w_d_s64 (int64x2_t left, int64x2_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// uint32x4_t vsrlrni_w_d_u64 (uint64x2_t left, uint64x2_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         ///// <summary>
-        ///// int64x2_t vsrlrni_d_q_s128 (int128x1_t left, int128x1_t right, const int n)
+        ///// 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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int8x8_t vsrlrn_b_h_s16 (int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        /// int8x8_t vsrlrn_b_h(int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
         ///   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_u16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_u32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_s64 (uint64x2_t value, uint64x2_t shift)
+        /// 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_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        /// int8x16_t vsrai_b(int8x16_t a, const int n) //qiaoqiao.ok.
         ///   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_s16 (int16x8_t a, const int n)
+        /// 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_s32 (int32x4_t a, const int n)
-        ///   LSX: VSRAI.W Vd.4S, Vj.4S, ui5
+        /// 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_s64 (int64x2_t a, const int n)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_s8 (int8x16_t a, const int n) //qiaoqiao.ok.
+        /// int8x16_t vsrari_b(int8x16_t a, const int n) //qiaoqiao.ok.
         ///   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_s16 (int16x8_t a, const int n)
+        /// 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_s32 (int32x4_t a, const int n)
+        /// 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_s64 (int64x2_t a, const int n)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_s16 (int16x8_t left, int16x8_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int16x8_t vsrarni_h_w_s32 (int32x4_t left, int32x4_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int32x4_t vsrarni_w_d_s64 (int64x2_t left, int64x2_t right, const int n)
+        /// 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         ///// <summary>
-        ///// int64x2_t vsrarni_d_q_s128 (int128x1_t left, int128x1_t right, const int n)
+        ///// 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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int8x8_t vsrarn_b_h_s16 (int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        /// int8x8_t vsrarn_b_h(int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
         ///   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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_u32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u8 (uint8x16_t a, const int n) //qiaoqiao.ok.
+        /// uint8x16_t vrotri_b(uint8x16_t a, const int n) //qiaoqiao.ok.
         ///   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_u8 (uint8x16_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u16 (uint16x8_t a, const int n)
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VROTRI.W Vd.4S, Vj.4S, ui5
+        /// 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_u32 (uint32x4_t a, const int n)
-        ///   LSX: VROTRI.W Vd.4S, Vj.4S, ui5
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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_u64 (uint64x2_t a, const int n)
+        /// 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_s8 (int8x16_t a, int8x16_t b)
+        /// 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_u8 (uint8x16_t a, uint8x16_t b)
+        /// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_u16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_u32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u64 (uint64x2_t value, uint64x2_t shift)
+        /// 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 vadda_b_s8 (int8x16_t a)
-        ///   LSX: VADDA.B Vd.16B, Vj.16B, 0
+        /// 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 vadda_h_s16 (int16x8_t a)
-        ///   LSX: VADDA.H Vd.8H, Vj.8H, 0
+        /// 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 vadda_w_s32 (int32x4_t a)
-        ///   LSX: VADDA.W Vd.4S, Vj.4S, 0
+        /// 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 vdda_d_s64 (int64x2_t a)
-        ///   LSX: VADDA.D Vd.2D, Vj.2D, 0
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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 vfsqrt_s_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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 vfrintrm_s_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_f32 (float32x4_t a)
+        /// 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_f64 (float64x2_t a)
+        /// 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_s8 (int8_t a, int8x16_t v, const int imm)
-        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// 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, byte index, sbyte data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint8x16_t vinsgr2vr_b_u8 (uint8_t a, uint8x16_t v, const int imm)
-        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        /// 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 index, byte data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int16x8_t vinsgr2vr_h_s16 (int16_t a, int16x8_t v, const int imm)
-        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// 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, byte index, short data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint16x8_t vinsgr2vr_h_u16 (uint16_t a, uint16x8_t v, const int imm)
-        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        /// 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, byte index, ushort data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int32x4_t vinsgr2vr_w_s32 (int32_t a, int32x4_t v, const int imm)
-        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// 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, byte index, int data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint32x4_t vinsgr2vr_w_u32 (uint32_t a, uint32x4_t v, const int imm)
-        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        /// 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, byte index, uint data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int64x2_t vinsgr2vr_d_s64 (int64_t a, int64x2_t v, const int imm)
-        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// 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, byte index, long data) => Insert(vector, index, data);
 
         /// <summary>
-        /// uint64x2_t vinsgr2vr_d_u64 (uint64_t a, uint64x2_t v, const int imm)
-        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        /// 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, byte index, ulong data) => Insert(vector, index, data);
 
         /// <summary>
-        /// float32x4_t xvinsve0_w_f32 (float32_t a, float32x4_t v, const int imm)
-        ///   LSX: XVINSVE0.W Vd.S[imm], Vj.S[0], imm
+        /// 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, byte index, float data) => Insert(vector, index, data);
 
         /// <summary>
-        /// float64x2_t xvinsve0_d_f64 (float64_t a, float64x2_t v, const int imm)
-        ///   LSX: XVINSVE0.D Vd.D[imm], Vj.D[0], imm
+        /// 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, byte index, double data) => Insert(vector, index, data);
 
         /// <summary>
-        /// int8x16_t vreplgr2vr_b_s8 (int8_t value)
+        /// 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_u8 (uint8_t value)
+        /// 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_s16 (int16_t value)
+        /// 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_u16 (uint16_t value)
+        /// 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_s32 (int32_t value)
+        /// 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_u32 (uint32_t value)
+        /// 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_s64 (int64_t value)
+        /// 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_u64 (uint64_t value)
+        /// 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_f32 (float32_t value)
+        /// 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_f64 (float64_t value)
+        /// 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_f32_s32 (int32x4_t a)
+        /// 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_f32_u32 (uint32x4_t a)
+        /// 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_f64_s64 (int64x2_t a)
+        /// 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_f64_u64 (uint64x2_t a)
+        /// 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_u8 (uint8x16_t value)
+        /// 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_u16 (uint16x8_t value)
+        /// 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_u8 (uint8x16_t value)
+        /// 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_u8 (uint8x16_t value)
+        /// 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_s8 (int8x16_t value)
+        /// 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_u8 (uint8x16_t value)
+        /// 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_s16 (int16x8_t value)
+        /// 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_u16 (uint16x8_t value)
+        /// 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_s32 (int32x4_t value)
+        /// 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_u32 (uint32x4_t value)
+        /// 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_s64 (int64x2_t value)
+        /// 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_u64 (uint64x2_t value)
+        /// 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_s8 (int8x16_t value)
+        /// 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_u8 (uint8x16_t value)
+        /// 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_s16 (int16x8_t value)
+        /// 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_u16 (uint16x8_t value)
+        /// 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_s32 (int32x4_t value)
+        /// 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_u32 (uint32x4_t value)
+        /// 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_s64 (int64x2_t value)
+        /// 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_u64 (uint64x2_t value)
+        /// 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_u16 (uint16x8_t left, uint16x8_t right, shift)
+        /// 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_s32 (int32x4_t left, int32x4_t right, shift)
+        /// 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_u32 (uint32x4_t left, uint32x4_t right, shift)
+        /// 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_s64 (int64x2_t left, int64x2_t right, shift)
+        /// 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_u64 (uint64x2_t left, uint64x2_t right, shift)
+        /// 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_u128 (uint128x1_t left, uint128x1_t right, shift)
+        ///// 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_s16 (int16x8_t value, int16x8_t shift)
+        /// 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_u16 (uint16x8_t value, uint16x8_t shift)
+        /// 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_s32 (int32x4_t value, int32x4_t shift)
+        /// 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_u32 (uint32x4_t value, uint32x4_t shift)
+        /// 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_s64 (int64x2_t value, int64x2_t shift)
+        /// 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_u64 (uint64x2_t value, uint64x2_t shift)
+        /// 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);
@@ -4109,176 +4511,176 @@ internal Lsx() { }
         public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value) => LeadingZeroCount(value);
 
         /// <summary>
-        /// int8x16_t vpcnt_b_s8 (int8x16_t a)
+        /// 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_u8 (uint8x16_t a)
+        /// 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_s16 (int16x8_t a)
+        /// 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_u16 (uint16x8_t a)
+        /// 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_s32 (int32x4_t a)
+        /// 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_u32 (uint32x4_t a)
+        /// 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_s64 (int64x2_t a)
+        /// 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_u64 (uint64x2_t a)
+        /// 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 vshuffle_u8(uint8x16_t vec, uint8x16_t idx)
+        ///  uint8x16_t vshuffle(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> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
 
         /// <summary>
-        ///  int8x16_t vshuffle_s8(int8x16_t vec, int8x16_t idx)
+        ///  int8x16_t vshuffle(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> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
 
         /// <summary>
-        ///  uint8x16_t vshuffle_u8(uint8x16_t vec0, uint8x16_t vec1, uint8x16_t idx)
+        ///  uint8x16_t vshuffle(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  int8x16_t vshuffle_s8(int8x16_t vec0, int8x16_t vec1, int8x16_t idx)
+        ///  int8x16_t vshuffle(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  int16x8_t vshuffle_s16(int16x8_t vec, int16x8_t idx)
-        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        ///  int16x8_t vshuffle(int16x8_t vec, int16x8_t idx)
+        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H                //NOTE: Vd is both input and output.
         /// </summary>
         public static Vector128<short> VectorShuffle(Vector128<short> vector, Vector128<short> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
 
         /// <summary>
-        ///  uint16x8_t vshuffle_u16(uint16x8_t vec, uint16x8_t idx)
+        ///  uint16x8_t vshuffle(uint16x8_t vec, uint16x8_t idx)
         ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
         public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector, Vector128<ushort> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
 
         /// <summary>
-        ///  int16x8_t vshuffle_s16(int16x8_t vec0, int16x8_t vec1, int16x8_t idx)
-        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        ///  int16x8_t vshuffle(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.
         /// </summary>
         public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  uint16x8_t vshuffle_u16(uint16x8_t vecj, uint16x8_t veck, uint16x8_t idx)
+        ///  uint16x8_t vshuffle(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> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  int32x4_t vshuffle_s32(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
+        ///  int32x4_t vshuffle(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
         ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
         /// </summary>
         public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  uint32x4_t vshuffle_u32(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
+        ///  uint32x4_t vshuffle(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
         ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
         /// </summary>
         public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  int64x2_t vshuffle_s64(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
+        ///  int64x2_t vshuffle(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
         ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
         /// </summary>
         public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  uint64x2_t vshuffle_u64(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
+        ///  uint64x2_t vshuffle(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
         ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
         /// </summary>
         public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
 
         /// <summary>
-        ///  uint8x16_t vreplve_u8(uint8x16_t vector, uint8_t idx)
+        ///  uint8x16_t vreplve(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_s8(int8x16_t vector, uint8_t idx)
+        ///  int8x16_t vreplve(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_s16(int16x8_t vector, uint8_t idx)
+        ///  int16x8_t vreplve(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_u16(uint16x8_t vector, uint8_t idx)
+        ///  uint16x8_t vreplve(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_s32(int32x4_t vector, uint8_t idx)
+        ///  int32x4_t vreplve(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_u32(uint32x4_t vector, uint8_t idx)
+        ///  uint32x4_t vreplve(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_s64(int64x2_t vector, uint8_t idx)
+        ///  int64x2_t vreplve(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_u32(uint64x2_t vector, uint8_t idx)
+        ///  uint64x2_t vreplve(uint64x2_t vector, uint8_t idx)
         ///   LSX: VREPLVE_D Vd.2D, Vj.2D, rk
         ///   LSX: VREPLVEI_D Vd.2D, Vj.2D, ui1
         /// </summary>
@@ -4310,13 +4712,13 @@ internal Lsx() { }
 
         /// <summary>
         /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
-        ///   LSX: VBITCLRI.W Vd.4S, Vj.4S, ui5
+        ///   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.4S, Vj.4S, ui5
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
         /// </summary>
         public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, const byte index) => VectorElementBitClear(value, index);
 
@@ -4406,13 +4808,13 @@ internal Lsx() { }
 
         /// <summary>
         /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
-        ///   LSX: VBITSETI.W Vd.4S, Vj.4S, ui5
+        ///   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.4S, Vj.4S, ui5
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
         /// </summary>
         public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, const byte index) => VectorElementBitSet(value, index);
 
@@ -4502,13 +4904,13 @@ internal Lsx() { }
 
         /// <summary>
         /// uint32x4_t  vbitrevi_w(uint32x4_t a, const int n)
-        ///   LSX: VBITREVI.W Vd.4S, Vj.4S, ui5
+        ///   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.4S, Vj.4S, ui5
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
         /// </summary>
         public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, const byte index) => VectorElementBitRevert(value, index);
 
@@ -4572,8 +4974,13 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, Vector128<ulong> index) => VectorElementBitRevert(value, index);
 
-        // TODO: other liking .......
-        // TODO:----------------------------------
+        // TODO: other liking VPICKVE2GR.{B/H/W/D}[U], VSHUF4I.{b/h/w/d}, VILV{L/H}, VBSLL.V, VBSRL.V, .......
+        // TODO:----- VPACK{EV/OD}.{B/H/W/D}, VPICK{EV/OD}.{B/H/W/D}, VEXTRINS.{B/H/W/D}, VMSKLTZ.{B/H/W/D}, VMSK{GEZ/NZ}.B,
+        //            XVPICKVE.{W/D}, XVPERM.W,  [X]VPREMI.W, XVPREMI.D, XVPREMI.Q,
+
+        //      [X]VFRSTP[I}.{B/H}
+        //      [X]VLDREPL.{B/H/W/D}, [X]VSTELM.{B/H/W/D}
+        //      [X]VF{NMADD/NMSUB}.{S/D},  [X]VF{MAXA/MINA}.{S/D}, [X]VFLOGB.{S/D}, [X]VFCLASS.{S/D}, 
 
     }
 }

From fc8d9825e1825a782742f271a9cb1ba3bcf2fa56 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Fri, 24 Nov 2023 17:58:45 +0800
Subject: [PATCH 07/11] Lsx-PartE, Lasx-PartD: add some add/madd operations,
 max/min, bitwise shift, shuffle, compare and float operations.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 644 +++++++++++++++-
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 708 +++++++++++++++---
 2 files changed, 1188 insertions(+), 164 deletions(-)

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
index d1f7f3b77ad80b..c43373faf6f0cb 100644
--- 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
@@ -750,19 +750,31 @@ internal Lasx() { }
 
         /// <summary>
         /// float32x8_t xvfmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
-        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
+        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
         /// </summary>
-        public static Vector256<float> FusedMultiplyAdd(Vector256<float> addend, Vector256<float> left, Vector256<float> right) => FusedMultiplyAdd(addend, left, right);
+        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
+        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
         /// </summary>
-        public static Vector256<double> FusedMultiplyAdd(Vector256<double> addend, Vector256<double> left, Vector256<double> right) => FusedMultiplyAdd(addend, left, right);
+        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
+        ///   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);
 
@@ -796,6 +808,42 @@ internal Lasx() { }
         /// </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
@@ -832,6 +880,18 @@ internal Lasx() { }
         /// </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
@@ -904,6 +964,18 @@ internal Lasx() { }
         /// </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
@@ -988,6 +1060,30 @@ internal Lasx() { }
         /// </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
@@ -1240,6 +1336,12 @@ internal Lasx() { }
         /// </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
@@ -1300,6 +1402,54 @@ internal Lasx() { }
         /// </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
@@ -1356,10 +1506,70 @@ internal Lasx() { }
 
         /// <summary>
         /// float64x4_t xvfmax_d(float64x4_t a, float64x4_t b)
-        ///   LASX: XVFMAX.d Xd.4D, Xj.4D, Xk.4D
+        ///   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
@@ -1420,6 +1630,18 @@ internal Lasx() { }
         /// </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
@@ -1624,6 +1846,30 @@ internal Lasx() { }
         /// </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> Logarithm2(Vector256<float> value) => Logarithm2(value);
+
+        /// <summary>
+        /// float64x4_t xvflogb_d(float64x4_t a)
+        ///   LASX: XVFLOGB.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Logarithm2(Vector256<double> value) => Logarithm2(value);
+
         /// <summary>
         /// void xvst(int8_t * ptr, int8x32_t val)
         ///   LASX: XVST { Xd.32B }, Rj, si12
@@ -1720,18 +1966,6 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<double> Negate(Vector256<double> value) => Negate(value);
 
-        /// <summary>
-        /// float32x8_t xvfmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
-        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S
-        /// </summary>
-        public static Vector256<float> FusedMultiplySubtract(Vector256<float> minuend, Vector256<float> left, Vector256<float> right) => FusedMultiplySubtract(minuend, left, right);
-
-        /// <summary>
-        /// float64x4_t xvfmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
-        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D
-        /// </summary>
-        public static Vector256<double> FusedMultiplySubtract(Vector256<double> minuend, Vector256<double> left, Vector256<double> right) => FusedMultiplySubtract(minuend, left, right);
-
         /// <summary>
         /// int16x16_t xvmulwod_h_b(int8x32_t a, int8x32_t b)
         ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
@@ -2756,6 +2990,18 @@ internal Lasx() { }
         /// </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>
@@ -2851,6 +3097,18 @@ internal Lasx() { }
         /// </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>
@@ -3348,18 +3606,6 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<double> Abs(Vector256<double> value) => Abs(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 xvfrintrm_s(float32x8_t a)
         ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
@@ -4272,53 +4518,335 @@ internal Lasx() { }
         /// </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>
         ///  uint8x32_t xvrepl128vei(uint8x32_t vector, uint8_t idx)
         ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
         /// </summary>
-        public static Vector256<byte> VectorElementReplicate(Vector256<byte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<sbyte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<short> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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: XVREPLVEI_H Xd.16H, Xj.16H, ui3
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
         /// </summary>
-        public static Vector256<ushort> VectorElementReplicate(Vector256<ushort> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<int> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<uint> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<long> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        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> VectorElementReplicate(Vector256<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+        public static Vector256<ulong> VectorElementReplicateEach128(Vector256<ulong> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <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)
@@ -4608,6 +5136,42 @@ internal Lasx() { }
         /// </summary>
         public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index) => VectorElementBitRevert(value, index);
 
-        // TODO:----------------------------------VectorShuffle
+        /// <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>
+        /// 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);
+
+        // TODO:----------------------------------
     }
 }
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
index 65faa9a0979660..bf22bff3f408ba 100644
--- 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
@@ -920,19 +920,31 @@ internal Lsx() { }
 
         /// <summary>
         /// float32x4_t vfmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S, Va.4S
         /// </summary>
-        public static Vector128<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) => FusedMultiplyAdd(addend, left, right);
+        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
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D, Va.2D
         /// </summary>
-        public static Vector128<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) => FusedMultiplyAdd(addend, left, right);
+        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
+        ///   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);
 
@@ -966,15 +978,51 @@ internal Lsx() { }
         /// </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
+        ///   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 TODO(uint8x16_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// 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);
 
@@ -985,8 +1033,8 @@ internal Lsx() { }
         public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right) => MultiplySubtract(minuend, left, right);
 
         /// <summary>
-        /// uint16x8_t TODO(uint16x8_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// 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);
 
@@ -1002,6 +1050,18 @@ internal Lsx() { }
         /// </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
@@ -1074,6 +1134,18 @@ internal Lsx() { }
         /// </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
@@ -1158,6 +1230,30 @@ internal Lsx() { }
         /// </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
@@ -1410,6 +1506,12 @@ internal Lsx() { }
         /// </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
@@ -1470,6 +1572,54 @@ internal Lsx() { }
         /// </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
@@ -1526,10 +1676,70 @@ internal Lsx() { }
 
         /// <summary>
         /// float64x2_t vfmax_d(float64x2_t a, float64x2_t b)
-        ///   LSX: VFMAX.d Vd.2D, Vj.2D, Vk.2D
+        ///   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
@@ -1590,6 +1800,18 @@ internal Lsx() { }
         /// </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
@@ -1794,6 +2016,30 @@ internal Lsx() { }
         /// </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> Logarithm2(Vector128<float> value) => Logarithm2(value);
+
+        /// <summary>
+        /// float64x2_t vflogb_d(float64x2_t a)
+        ///   LSX: VFLOGB.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Logarithm2(Vector128<double> value) => Logarithm2(value);
+
         /// <summary>
         /// void vst(int8_t * ptr, int8x16_t val)
         ///   LSX: VST Vd.16B, Rj, si12
@@ -1902,18 +2148,6 @@ internal Lsx() { }
         /// </summary>
         public static Vector64<float> NegateScalar(Vector64<float> value) => NegateScalar(value);
 
-        /// <summary>
-        /// float32x4_t vfmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
-        /// </summary>
-        public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right) => FusedMultiplySubtract(minuend, left, right);
-
-        /// <summary>
-        /// float64x2_t vfmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
-        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D
-        /// </summary>
-        public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right) => FusedMultiplySubtract(minuend, left, right);
-
         /// <summary>
         /// int16x8_t vmulwod_h_b(int8x16_t a, int8x16_t b)
         ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
@@ -2912,49 +3146,61 @@ internal Lsx() { }
         /// int8x16_t vslli_b(int8x16_t a, const int n) //qiaoqiao.ok.
         ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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 const byte shift) => ShiftLeftLogical(value, shift);
+        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)
@@ -3052,6 +3298,18 @@ internal Lsx() { }
         /// </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
@@ -3550,18 +3808,6 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<double> Abs(Vector128<double> value) => Abs(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 vfrintrm_s(float32x4_t a)
         ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
@@ -4558,134 +4804,302 @@ internal Lsx() { }
         /// </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 vshuffle(uint8x16_t vec, uint8x16_t idx)
-        ///   LSX: VSHUF_B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        ///  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> vector, Vector128<byte> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  int8x16_t vshuffle(int8x16_t vec, int8x16_t idx)
-        ///   LSX: VSHUF_B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        ///  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> vector, Vector128<sbyte> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  uint8x16_t vshuffle(uint8x16_t vec0, uint8x16_t vec1, uint8x16_t idx)
-        ///   LSX: VSHUF_B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        ///  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<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  int8x16_t vshuffle(int8x16_t vec0, int8x16_t vec1, int8x16_t idx)
-        ///   LSX: VSHUF_B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        ///  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<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  int16x8_t vshuffle(int16x8_t vec, int16x8_t idx)
-        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H                //NOTE: Vd is both input and output.
+        ///  int32x4_t vpermi_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<short> VectorShuffle(Vector128<short> vector, Vector128<short> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+        public static Vector128<int> VectorShuffle(Vector128<int> vector, const byte indexs) => VectorShuffle(vector, indexs);
 
         /// <summary>
-        ///  uint16x8_t vshuffle(uint16x8_t vec, uint16x8_t idx)
-        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        ///  uint32x4_t vpermi_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector, Vector128<ushort> byteIndexes) => VectorElementReplicate(vector, byteIndexes);
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector, const byte indexs) => VectorShuffle(vector, indexs);
 
         /// <summary>
-        ///  int16x8_t vshuffle(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.
+        ///  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<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  uint16x8_t vshuffle(uint16x8_t vecj, uint16x8_t veck, uint16x8_t idx)
-        ///   LSX: VSHUF_H Vd.8H, Vj.8H, Vk.8H
+        ///  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<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  int32x4_t vshuffle(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
-        ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
+        ///  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<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  uint32x4_t vshuffle(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
-        ///   LSX: VSHUF_H Vd.4W, Vj.4W, Vk.4W
+        ///  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<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> indexs) => VectorShuffle(vector0, vector1, indexs);
 
         /// <summary>
-        ///  int64x2_t vshuffle(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
-        ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
+        ///  int8x16_t vshuf4i_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<sbyte> VectorShuffleBy4Elements(Vector128<sbyte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
 
         /// <summary>
-        ///  uint64x2_t vshuffle(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
-        ///   LSX: VSHUF_H Vd.2D, Vj.2D, Vk.2D
+        ///  uint8x16_t vshuf4i_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> byteIndexes) => VectorShuffle(vector0, vector1, byteIndexes);
+        public static Vector128<byte> VectorShuffleBy4Elements(Vector128<byte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
 
         /// <summary>
-        ///  uint8x16_t vreplve(uint8x16_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_B Vd.16B, Vj.16B, rk
-        ///   LSX: VREPLVEI_B Vd.16B, Vj.16B, ui4
+        ///  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>
+        ///  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(int8x16_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_B Vd.16B, Vj.16B, rk
-        ///   LSX: VREPLVEI_B Vd.16B, Vj.16B, ui4
+        ///  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(int16x8_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_H Vd.8H, Vj.8H, rk
-        ///   LSX: VREPLVEI_H Vd.8H, Vj.8H, ui3
+        ///  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(uint16x8_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_H Vd.8H, Vj.8H, rk
-        ///   LSX: VREPLVEI_H Vd.8H, Vj.8H, ui3
+        ///  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(int32x4_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_W Vd.4W, Vj.4W, rk
-        ///   LSX: VREPLVEI_W Vd.4W, Vj.4W, ui2
+        ///  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(uint32x4_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_W Vd.4W, Vj.4W, rk
-        ///   LSX: VREPLVEI_W Vd.4W, Vj.4W, ui2
+        ///  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(int64x2_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_D Vd.2D, Vj.2D, rk
-        ///   LSX: VREPLVEI_D Vd.2D, Vj.2D, ui1
+        ///  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(uint64x2_t vector, uint8_t idx)
-        ///   LSX: VREPLVE_D Vd.2D, Vj.2D, rk
-        ///   LSX: VREPLVEI_D Vd.2D, Vj.2D, ui1
+        ///  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 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
@@ -4879,108 +5293,154 @@ internal Lsx() { }
         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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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)
+        /// 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);
 
-        // TODO: other liking VPICKVE2GR.{B/H/W/D}[U], VSHUF4I.{b/h/w/d}, VILV{L/H}, VBSLL.V, VBSRL.V, .......
-        // TODO:----- VPACK{EV/OD}.{B/H/W/D}, VPICK{EV/OD}.{B/H/W/D}, VEXTRINS.{B/H/W/D}, VMSKLTZ.{B/H/W/D}, VMSK{GEZ/NZ}.B,
-        //            XVPICKVE.{W/D}, XVPERM.W,  [X]VPREMI.W, XVPREMI.D, XVPREMI.Q,
+        /// <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>
+        /// 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);
+
+        // TODO: other liking VPICKVE2GR.{B/H/W/D}[U],  .......
+        // TODO:----- VPACK{EV/OD}.{B/H/W/D}, VPICK{EV/OD}.{B/H/W/D}, VEXTRINS.{B/H/W/D},
+        //            XVPICKVE.{W/D},
 
-        //      [X]VFRSTP[I}.{B/H}
         //      [X]VLDREPL.{B/H/W/D}, [X]VSTELM.{B/H/W/D}
-        //      [X]VF{NMADD/NMSUB}.{S/D},  [X]VF{MAXA/MINA}.{S/D}, [X]VFLOGB.{S/D}, [X]VFCLASS.{S/D}, 
+
+        ///// <summary>
+        /////  int16x8_t vextrins_h(int16x8_t vec, uint8_t idx)
+        /////   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
+        ///// </summary>
+        //public static Vector128<short> VectorShuffle(Vector128<short> vector, const byte indexs) => VectorShuffle(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> VectorShuffle(Vector128<ushort> vector, const byte indexs) => VectorShuffle(vector, indexs);
 
     }
 }

From 9c0c63140389c20758b7c4b9155bf88926ae06f9 Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Wed, 29 Nov 2023 14:46:55 +0800
Subject: [PATCH 08/11]     Lsx-PartF, Lasx-PartE: amend the Load/Store
 Vector128/256,     add LoadElementReplicateVector, Vector elements'
 operations and AverageRounded.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 666 ++++++++++++++++--
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 625 +++++++++++++---
 2 files changed, 1132 insertions(+), 159 deletions(-)

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
index c43373faf6f0cb..fa4e94e907008d 100644
--- 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
@@ -1763,64 +1763,184 @@ internal Lasx() { }
         //public static Vector256<double> AbsoluteDifference(Vector256<double> left, Vector256<double> right) => AbsoluteDifference(left, right);
 
         /// <summary>
-        /// int8x32_t xvld(int8_t const * ptr)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)
+        /// 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) => LoadVector256(address);
+        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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const short si12) => LoadElementReplicateVector(address, si12);
 
         /// <summary>
         /// float32x8_t xvfrecip_s(float32x8_t a)
@@ -1871,64 +1991,184 @@ internal Lasx() { }
         public static Vector256<double> Logarithm2(Vector256<double> value) => Logarithm2(value);
 
         /// <summary>
-        /// void xvst(int8_t * ptr, int8x32_t val)
-        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// 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(sbyte* address, Vector256<sbyte> source) => Store(address, source);
+        public static unsafe void Store(Vector256<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void xvst(uint8_t * ptr, uint8x32_t val)
-        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// void xvst(float64x4_t val, float64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
         /// </summary>
-        public static unsafe void Store(byte* address, Vector256<byte> source) => Store(address, source);
+        public static unsafe void Store(Vector256<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void xvst(int16_t * ptr, int16x16_t val)
-        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// void xvstx(int8x32_t val, int8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
         /// </summary>
-        public static unsafe void Store(short* address, Vector256<short> source) => Store(address, source);
+        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(uint16_t * ptr, uint16x16_t val)
-        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// void xvstx(uint8x32_t val, uint8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
         /// </summary>
-        public static unsafe void Store(ushort* address, Vector256<ushort> source) => Store(address, source);
+        public static unsafe void Store(Vector256<byte> vector, byte* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(int32_t * ptr, int32x8_t val)
-        ///   LASX: XVST { Xd.8W }, Rj, si12
+        /// void xvstx(int16x16_t val, int16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
         /// </summary>
-        public static unsafe void Store(int* address, Vector256<int> source) => Store(address, source);
+        public static unsafe void Store(Vector256<short> vector, short* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(uint32_t * ptr, uint32x8_t val)
-        ///   LASX: XVST { Xd.8W }, Rj, si12
+        /// void xvstx(uint16x16_t val, uint16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
         /// </summary>
-        public static unsafe void Store(uint* address, Vector256<uint> source) => Store(address, source);
+        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(int64_t * ptr, int64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// void xvstx(int32x8_t val, int32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
         /// </summary>
-        public static unsafe void Store(long* address, Vector256<long> source) => Store(address, source);
+        public static unsafe void Store(Vector256<int> vector, int* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(uint64_t * ptr, uint64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// void xvstx(uint32x8_t val, uint32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
         /// </summary>
-        public static unsafe void Store(ulong* address, Vector256<ulong> source) => Store(address, source);
+        public static unsafe void Store(Vector256<uint> vector, uint* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(float32_t * ptr, float32x8_t val)
-        ///   LASX: XVST { Xd.8W }, Rj, si12
+        /// void xvstx(int64x4_t val, int64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
         /// </summary>
-        public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source);
+        public static unsafe void Store(Vector256<long> vector, long* addr, long offsetValue) => Store(vector, addr, offsetValue);
 
         /// <summary>
-        /// void xvst(float64_t * ptr, float64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// void xvstx(uint64x4_t val, uint64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
         /// </summary>
-        public static unsafe void Store(double* address, Vector256<double> source) => Store(address, source);
+        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)
@@ -2158,6 +2398,54 @@ internal Lasx() { }
         /// </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
@@ -2943,7 +3231,7 @@ internal Lasx() { }
         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) //qiaoqiao.ok
+        /// 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);
@@ -3050,7 +3338,7 @@ internal Lasx() { }
         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) //qiaoqiao.ok
+        /// 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);
@@ -3157,7 +3445,7 @@ internal Lasx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3253,7 +3541,7 @@ internal Lasx() { }
         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)  qiaoqiao.ok.
+        /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
@@ -3295,7 +3583,7 @@ internal Lasx() { }
         //public static Vector256<long> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int8x16_t xvsrlrn_b_h(int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        /// 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);
@@ -3355,7 +3643,7 @@ internal Lasx() { }
         //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
 
         /// <summary>
-        /// int8x16_t xvsrarn_b_h(int16x16_t value, int16x16_t shift)  qiaoqiao.ok.
+        /// 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);
@@ -3379,7 +3667,7 @@ internal Lasx() { }
         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)//qiaoqiao.ok.
+        /// 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);
@@ -3427,7 +3715,7 @@ internal Lasx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3475,7 +3763,7 @@ internal Lasx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3670,61 +3958,61 @@ internal Lasx() { }
         /// 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, byte index, sbyte data) => Insert(vector, index, data);
+        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 index, byte data) => Insert(vector, index, data);
+        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, byte index, short data) => Insert(vector, index, data);
+        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, byte index, ushort data) => Insert(vector, index, data);
+        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, byte index, int data) => Insert(vector, index, data);
+        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, byte index, uint data) => Insert(vector, index, data);
+        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, byte index, long data) => Insert(vector, index, data);
+        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, byte index, ulong data) => Insert(vector, index, data);
+        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, byte index, float data) => Insert(vector, index, data);
+        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, byte index, double data) => Insert(vector, index, data);
+        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)
@@ -4776,6 +5064,198 @@ internal Lasx() { }
         /// </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
@@ -4824,6 +5304,54 @@ internal Lasx() { }
         /// </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
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
index bf22bff3f408ba..90c769582b746d 100644
--- 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
@@ -1933,64 +1933,184 @@ internal Lsx() { }
         //public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right) => AbsoluteDifference(left, right);
 
         /// <summary>
-        /// int8x16_t vld(int8_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// uint8x16_t vld(uint8_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<byte> LoadVector128(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// int16x8_t vld(int16_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<short> LoadVector128(short* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// uint16x8_t vld(uint16_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// int32x4_t vld(int32_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<int> LoadVector128(int* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// uint32x4_t vld(uint32_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<uint> LoadVector128(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// int64x2_t vld(int64_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<long> LoadVector128(long* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// uint64x2_t vld(uint64_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// float32x4_t vld(float32_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<float> LoadVector128(float* address, [ConstantExpected(Min = -2048, Max = 2047)] const short si12) => LoadVector128(address, si12);
 
         /// <summary>
-        /// float64x2_t vld(float64_t const * ptr)
+        /// 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) => LoadVector128(address);
+        public static unsafe Vector128<double> LoadVector128(double* address, [ConstantExpected(Min = -2048, Max = 2047)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const 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)] const short si12) => LoadElementReplicateVector(address, si12);
 
         /// <summary>
         /// float32x4_t vfrecip_s(float32x4_t a)
@@ -2041,64 +2161,124 @@ internal Lsx() { }
         public static Vector128<double> Logarithm2(Vector128<double> value) => Logarithm2(value);
 
         /// <summary>
-        /// void vst(int8_t * ptr, int8x16_t val)
+        /// void vst(int8x16_t val, int8_t* addr, const short si12)
         ///   LSX: VST Vd.16B, Rj, si12
         /// </summary>
-        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) => Store(address, source);
+        public static unsafe void Store(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(uint8_t * ptr, uint8x16_t val)
+        /// void vst(uint8x16_t val, uint8_t* addr, const short si12)
         ///   LSX: VST Vd.16B, Rj, si12
         /// </summary>
-        public static unsafe void Store(byte* address, Vector128<byte> source) => Store(address, source);
+        public static unsafe void Store(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(int16_t * ptr, int16x8_t val)
+        /// void vst(int16x8_t val, int16_t* addr, const short si12)
         ///   LSX: VST Vd.8H, Rj, si12
         /// </summary>
-        public static unsafe void Store(short* address, Vector128<short> source) => Store(address, source);
+        public static unsafe void Store(Vector128<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(uint16_t * ptr, uint16x8_t val)
+        /// void vst(uint16x8_t val, uint16_t* addr, const short si12)
         ///   LSX: VST Vd.8H, Rj, si12
         /// </summary>
-        public static unsafe void Store(ushort* address, Vector128<ushort> source) => Store(address, source);
+        public static unsafe void Store(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(int32_t * ptr, int32x4_t val)
+        /// void vst(int32x4_t val, int32_t* addr, const short si12)
         ///   LSX: VST Vd.4W, Rj, si12
         /// </summary>
-        public static unsafe void Store(int* address, Vector128<int> source) => Store(address, source);
+        public static unsafe void Store(Vector128<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(uint32_t * ptr, uint32x4_t val)
+        /// void vst(uint32x4_t val, uint32_t* addr, const short si12)
         ///   LSX: VST Vd.4W, Rj, si12
         /// </summary>
-        public static unsafe void Store(uint* address, Vector128<uint> source) => Store(address, source);
+        public static unsafe void Store(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(int64_t * ptr, int64x2_t val)
+        /// void vst(int64x2_t val, int64_t* addr, const short si12)
         ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
-        public static unsafe void Store(long* address, Vector128<long> source) => Store(address, source);
+        public static unsafe void Store(Vector128<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(uint64_t * ptr, uint64x2_t val)
+        /// void vst(uint64x2_t val, uint64_t* addr, const short si12)
         ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
-        public static unsafe void Store(ulong* address, Vector128<ulong> source) => Store(address, source);
+        public static unsafe void Store(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(float32_t * ptr, float32x4_t val)
+        /// void vst(float32x4_t val, float32_t* addr, const short si12)
         ///   LSX: VST Vd.4S, Rj, si12
         /// </summary>
-        public static unsafe void Store(float* address, Vector128<float> source) => Store(address, source);
+        public static unsafe void Store(Vector128<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
 
         /// <summary>
-        /// void vst(float64_t * ptr, float64x2_t val)
+        /// void vst(float64x2_t val, float64_t* addr, const short si12)
         ///   LSX: VST Vd.2D, Rj, si12
         /// </summary>
-        public static unsafe void Store(double* address, Vector128<double> source) => Store(address, source);
+        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)
@@ -2340,9 +2520,53 @@ internal Lsx() { }
         /// </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);
 
-        ////qiaoqiao. TODO.
-        public static Vector128<ulong> AverageRounded(Vector128<ulong> left, Vector128<ulong> right) => Average(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)
@@ -3143,7 +3367,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3251,7 +3475,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3359,7 +3583,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3455,7 +3679,7 @@ internal Lsx() { }
         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)  qiaoqiao.ok.
+        /// 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
@@ -3497,7 +3721,7 @@ internal Lsx() { }
         //public static Vector128<long> ShiftRightLogicalRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int8x8_t vsrlrn_b_h(int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        /// 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);
@@ -3533,7 +3757,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3581,7 +3805,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3653,7 +3877,7 @@ internal Lsx() { }
         //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
-        /// int8x8_t vsrarn_b_h(int16x8_t value, int16x8_t shift)  qiaoqiao.ok.
+        /// 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);
@@ -3677,7 +3901,7 @@ internal Lsx() { }
         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) //qiaoqiao.ok.
+        /// 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);
@@ -3872,61 +4096,61 @@ internal Lsx() { }
         /// 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, byte index, sbyte data) => Insert(vector, index, data);
+        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 index, byte data) => Insert(vector, index, data);
+        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, byte index, short data) => Insert(vector, index, data);
+        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, byte index, ushort data) => Insert(vector, index, data);
+        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, byte index, int data) => Insert(vector, index, data);
+        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, byte index, uint data) => Insert(vector, index, data);
+        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, byte index, long data) => Insert(vector, index, data);
+        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, byte index, ulong data) => Insert(vector, index, data);
+        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, byte index, float data) => Insert(vector, index, data);
+        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, byte index, double data) => Insert(vector, index, data);
+        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)
@@ -4804,17 +5028,17 @@ internal Lsx() { }
         /// </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>
+        ///  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>
+        ///  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)
@@ -5020,6 +5244,198 @@ internal Lsx() { }
         /// </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
@@ -5076,6 +5492,54 @@ internal Lsx() { }
         /// </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
@@ -5423,24 +5887,5 @@ internal Lsx() { }
         ///   LSX: VFCLASS.D Vd.2D, Vj.2D
         /// </summary>
         public static Vector128<long> FloatClass(Vector128<double> value) => FloatClass(value);
-
-        // TODO: other liking VPICKVE2GR.{B/H/W/D}[U],  .......
-        // TODO:----- VPACK{EV/OD}.{B/H/W/D}, VPICK{EV/OD}.{B/H/W/D}, VEXTRINS.{B/H/W/D},
-        //            XVPICKVE.{W/D},
-
-        //      [X]VLDREPL.{B/H/W/D}, [X]VSTELM.{B/H/W/D}
-
-        ///// <summary>
-        /////  int16x8_t vextrins_h(int16x8_t vec, uint8_t idx)
-        /////   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
-        ///// </summary>
-        //public static Vector128<short> VectorShuffle(Vector128<short> vector, const byte indexs) => VectorShuffle(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> VectorShuffle(Vector128<ushort> vector, const byte indexs) => VectorShuffle(vector, indexs);
-
     }
 }

From 2bbf4d1eee39b60dd357b3e9ce82add0bdcab4ab Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Wed, 29 Nov 2023 16:10:51 +0800
Subject: [PATCH 09/11] LoongArchBase: add CRC-32 and some float operations.

---
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      |   4 +-
 .../Intrinsics/LoongArch/LoongArchBase.cs     | 117 ++++++++++++++++--
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       |   4 +-
 3 files changed, 112 insertions(+), 13 deletions(-)

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
index fa4e94e907008d..284fff38635e40 100644
--- 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
@@ -1982,13 +1982,13 @@ internal Lasx() { }
         /// float32x8_t xvflogb_d(float32x8_t a)
         ///   LASX: XVFLOGB.S Xd.8S, Xj.8S
         /// </summary>
-        public static Vector256<float> Logarithm2(Vector256<float> value) => Logarithm2(value);
+        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> Logarithm2(Vector256<double> value) => Logarithm2(value);
+        public static Vector256<double> FloatLogarithm2(Vector256<double> value) => FloatLogarithm2(value);
 
         /// <summary>
         /// void xvst(int8x32_t val, int8_t* addr, const short si12)
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
index a997d1df54258b..03c8b31650f0b3 100644
--- 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
@@ -153,47 +153,146 @@ internal LoongArch64() { }
             /// </summary>
             public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);
 
-            // TODO: add crc, ????
+            /// <summary>
+            ///   LA64: FRECIPE.S fd, fj
+            /// </summary>
+            public static float ReciprocalExact(float value) => ReciprocalExact(value);
+
+            /// <summary>
+            ///   LA64: FRECIPE.D fd, fj
+            /// </summary>
+            public static double ReciprocalExact(double value) => ReciprocalExact(value);
+
+            /// <summary>
+            ///   LA64: FRSQRTE.S fd, fj
+            /// </summary>
+            public static float ReciprocalSqrtExact(float value) => ReciprocalSqrtExact(value);
+
+            /// <summary>
+            ///   LA64: FRSQRTE.D fd, fj
+            /// </summary>
+            public static double ReciprocalSqrtExact(double value) => ReciprocalSqrtExact(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: MULH.W rd, rj, rk
+        ///   LA32/LA64: MULH.W rd, rj, rk
         /// </summary>
         public static long MultiplyHigh(int left, int right) => MultiplyHigh(left, right);
 
         /// <summary>
-        ///   LA32: MULH.WU rd, rj, rk
+        ///   LA32/LA64: MULH.WU rd, rj, rk
         /// </summary>
         public static ulong MultiplyHigh(uint left, uint right) => MultiplyHigh(left, right);
 
         /// <summary>
-        ///   LA32: FSQRT.S fd, fj
+        ///   LA32/LA64: FSQRT.S fd, fj
         /// </summary>
         public static float SquareRoot(float value) => SquareRoot(value);
 
         /// <summary>
-        ///   LA32: FSQRT.D fd, fj
+        ///   LA32/LA64: FSQRT.D fd, fj
         /// </summary>
         public static double SquareRoot(double value) => SquareRoot(value);
 
         /// <summary>
-        ///   LA32: FRECIP.S fd, fj
+        ///   LA32/LA64: FRECIP.S fd, fj
         /// </summary>
         public static float Reciprocal(float value) => Reciprocal(value);
 
         /// <summary>
-        ///   LA32: FRECIP.D fd, fj
+        ///   LA32/LA64: FRECIP.D fd, fj
         /// </summary>
         public static double Reciprocal(double value) => Reciprocal(value);
 
         /// <summary>
-        ///   LA32: FRSQRT.S fd, fj
+        ///   LA32/LA64: FRSQRT.S fd, fj
         /// </summary>
         public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);
 
         /// <summary>
-        ///   LA32: FRSQRT.D fd, fj
+        ///   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.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
index 90c769582b746d..5b597ced55a23c 100644
--- 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
@@ -2152,13 +2152,13 @@ internal Lsx() { }
         /// float32x4_t vflogb_s(float32x4_t a)
         ///   LSX: VFLOGB.S Vd.4S, Vj.4S
         /// </summary>
-        public static Vector128<float> Logarithm2(Vector128<float> value) => Logarithm2(value);
+        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> Logarithm2(Vector128<double> value) => Logarithm2(value);
+        public static Vector128<double> FloatLogarithm2(Vector128<double> value) => FloatLogarithm2(value);
 
         /// <summary>
         /// void vst(int8x16_t val, int8_t* addr, const short si12)

From 6c7b3801d83a62412234efdaf92d5655aa8a13cc Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Wed, 29 Nov 2023 17:38:35 +0800
Subject: [PATCH 10/11] update the *PlatformNotSupported.cs and
 ref/System.Runtime.Intrinsics.cs.

---
 .../LoongArch/Lasx.PlatformNotSupported.cs    | 5634 ++++++++++++----
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      |  188 +-
 .../LoongArchBase.PlatformNotSupported.cs     |  359 +-
 .../Intrinsics/LoongArch/LoongArchBase.cs     |    9 +-
 .../LoongArch/Lsx.PlatformNotSupported.cs     | 5919 +++++++++++++----
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       |  238 +-
 .../ref/System.Runtime.Intrinsics.cs          | 1997 ++++--
 7 files changed, 11167 insertions(+), 3177 deletions(-)

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
index 2a754eeacc9c6a..c8889fd206a529 100644
--- 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
@@ -3,7 +3,7 @@
 
 using System.Runtime.CompilerServices;
 
-namespace System.Runtime.Intrinsics.LoongArch64
+namespace System.Runtime.Intrinsics.LoongArch
 {
     /// <summary>
     /// This class provides access to the LASX-256bits hardware instructions via intrinsics
@@ -14,2260 +14,5670 @@ namespace System.Runtime.Intrinsics.LoongArch64
 #else
     internal
 #endif
-    abstract class LA_LASX : LA_LSX
+    abstract class Lasx : Lsx
     {
-        internal LA_LASX() { }
+        internal Lasx() { }
 
         public static new bool IsSupported { [Intrinsic] get { return false; } }
 
         /// <summary>
-        /// int8x32_t xvadd_b_s8 (int8x32_t a, int8x32_t b)
+        /// 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 TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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_s16 (int16x16_t a, int16x16_t b)
+        /// 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 TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVADD.W Xd.8S, Xj.8S, Xk.8S
+        /// 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 TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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_s64 (int64x4_t a, int64x4_t b)
+        /// 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 TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// 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_f32 (float32x8_t a, float32x8_t b)
+        /// 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_f64 (float64x4_t a, float64x4_t b)
+        /// 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 xvsub_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// int8x32_t xvsadd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSADD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// int16x16_t xvsadd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSADD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvsub_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// int32x8_t xvsadd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSADD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvsadd_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSADD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvsub_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvsadd_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSADD.BU Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// uint16x16_t xvsadd_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSADD.HU Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvsub_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvsadd_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSADD.WU Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// uint64x4_t xvsadd_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSADD.DU Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfsub_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// 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<float> Subtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> AddOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfsub_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<double> Subtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> AddOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvmul_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
+        /// 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<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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<byte> Multiply(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> AddOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmul_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
+        /// 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<short> Multiply(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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<ushort> Multiply(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> AddOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmul_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMULW Xd.8S, Xj.8S, Xk.8S
+        /// 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<int> Multiply(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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<uint> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmul_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<long> Multiply(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t TODO_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// 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<ulong> Multiply(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> AddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfmul_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFMUL.S Xd.8S, Xj.8S, Xk.8S
+        /// 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<float> Multiply(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfmul_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<double> Multiply(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> AddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvdiv_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVDIV.B Xd.32B, Xj.32B, Xk.32B
+        /// 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<sbyte> Divide(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvdiv_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVDIV.BU Xd.32B, Xj.32B, Xk.32B
+        /// 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<byte> Divide(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvdiv_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVDIV.H Xd.16H, Xj.16H, Xk.16H
+        /// 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<short> Divide(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvdiv_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVDIV.HU Xd.16H, Xj.16H, Xk.16H
+        /// 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<ushort> Divide(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvdiv_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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<int> Divide(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddOddElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvdiv_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVDIV.WU Xd.8S, Xj.8S, Xk.8S
+        /// 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<uint> Divide(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> AddOddElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvdiv_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<long> Divide(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddOddElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvdiv_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVDIV.DU Xd.4D, Xj.4D, Xk.4D
+        /// 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<ulong> Divide(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> AddOddElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfdiv_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFDIV.S Xd.8S, Xj.8S, Xk.8S
+        /// 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<float> Divide(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddOddElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfdiv_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<double> Divide(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfmadd_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
-        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S
+        /// 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<float> FusedMultiplyAdd(Vector256<float> addend, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddOddElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfmadd_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
-        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// 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<double> FusedMultiplyAdd(Vector256<double> addend, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvmadd_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
-        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
+        /// 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<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddEvenElementsWidening(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// 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<byte> MultiplyAdd(Vector256<byte> addend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddEvenElementsWidening(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmadd_h_s16 (int16x16_t a, int16x16_t b, int16x16_t c)
-        ///   LASX: XVMADD.H Xd.16H, Xj.16H, Xk.16H
+        /// 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<short> MultiplyAdd(Vector256<short> addend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddEvenElementsWidening(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// 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<ushort> MultiplyAdd(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddEvenElementsWidening(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmadd_w_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMADD.W Xd.8S, Xj.8S, Xk.8S
+        /// 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<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AddOddElementsWidening(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// 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<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AddOddElementsWidening(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t TODO_s8 (int8x32_t a, uint8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B
+        /// 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<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddOddElementsWidening(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, int8x32_t b)
-        ///   LASX: TODO Xd.32B, Xj.32B
+        /// 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<byte> AddSaturate(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AddOddElementsWidening(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t TODO_s16 (int16x16_t a, uint16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.H.B Xd.16H, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, int16x16_t b)
-        ///   LASX: TODO Xd.16H, Xj.16H
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.HU.BU Xd.16H, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t TODO_s32 (int32x8_t a, uint32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.W.H Xd.8W, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, int32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.WU.HU Xd.8W, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t TODO_s64 (int64x4_t a, uint64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.D.W Xd.4D, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t TODO_u64 (uint64x4_t a, int64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.DU.WU Xd.4D, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvsadd_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSADD.B Xd.32B, Xj.32B, Xk.32B
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.Q.D Xd.2Q, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvsadd_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSADD.H Xd.16H, Xj.16H, Xk.16H
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.QU.DU Xd.2Q, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvsadd_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSADD.W Xd.8S, Xj.8S, Xk.8S
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_float_elements witin vector.
         /// </summary>
-        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> AddHorizontalElements(Vector256<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvsadd_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSADD.D Xd.4D, Xj.4D, Xk.4D
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_double_elements witin vector.
         /// </summary>
-        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<double> AddHorizontalElements(Vector256<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsadd_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSADD.BU Xd.32B, Xj.32B, Xk.32B
+        /// int8x32_t xvsub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsadd_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSADD.HU Xd.16H, Xj.16H, Xk.16H
+        /// uint8x32_t xvsub_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsadd_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSADD.WU Xd.8S, Xj.8S, Xk.8S
+        /// int16x16_t xvsub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsadd_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSADD.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16_t xvsub_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvmsub_b_s8 (int8x32_t a, int8x32_t b, int8x32_t c)
-        ///   LASX: XVMSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// int32x8_t xvsub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<sbyte> MultiplySubtract(Vector256<sbyte> minuend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: TODO Xd.32B, Xj.32B, Xk.32B
+        /// uint32x8_t xvsub_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<byte> MultiplySubtract(Vector256<byte> minuend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmsub_h_s16 (int16x16_t a, int16x16_t b, int16x16_t c)
-        ///   LASX: XVMSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvsub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> MultiplySubtract(Vector256<short> minuend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: TODO Xd.16H, Xj.16H, Xk.16H
+        /// uint64x4_t xvsub_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ushort> MultiplySubtract(Vector256<ushort> minuend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmsub_w_s32 (int32x8_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// float32x8_t xvfsub_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFSUB.S Xd.8S, Xj.8S, Xk.8S
         /// </summary>
-        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t TODO_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// float64x4_t xvfsub_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFSUB.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmaddwev_h_b_s8 (int16x16_t a, int8x8_t b, int8x8_t c)
-        ///   LASX: XVMADDWEV.H.B Xd.16H, Xj.8B, Xk.8B
+        /// 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<short> MultiplyWideningLowerAndAdd(Vector256<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> SubtractOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvmaddwev_h_bu_u8 (uint16x16_t a, uint8x8_t b, uint8x8_t c)
-        ///   LASX: XVMADDWEV.H.BU Xd.16H, Xj.8B, Xk.8B
+        /// 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<ushort> MultiplyWideningLowerAndAdd(Vector256<ushort> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> SubtractOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmaddwev_w_h_s16 (int32x8_t a, int16x4_t b, int16x4_t c)
-        ///   LASX: XVMADDWEV.W.H Xd.8S, Xj.4H, Xk.4H
+        /// 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<int> MultiplyWideningLowerAndAdd(Vector256<int> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> SubtractOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvmaddwev_w_hu_u16 (uint32x8_t a, uint16x4_t b, uint16x4_t c)
-        ///   LASX: XVMADDWEV.W.HU Xd.8S, Xj.4H, Xk.4H
+        /// 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<uint> MultiplyWideningLowerAndAdd(Vector256<uint> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> SubtractOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmaddwev_d_w_s32 (int64x4_t a, int32x2_t b, int32x2_t c)
-        ///   LASX: XVMADDWEV.D.W Xd.4D, Xj.2S, Xk.2S
+        /// 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<long> MultiplyWideningLowerAndAdd(Vector256<long> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> SubtractOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvmaddwev_d_wu_u32 (uint64x4_t a, uint32x2_t b, uint32x2_t c)
-        ///   LASX: XVMADDWEV.D.WU Xd.4D, Xj.2S, Xk.2S
+        /// 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<ulong> MultiplyWideningLowerAndAdd(Vector256<ulong> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> SubtractOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmaddwod_h_b_s8 (int16x16_t a, int8x32_t b, int8x32_t c)
-        ///   LASX: XVMADDWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// 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<short> MultiplyWideningUpperAndAdd(Vector256<short> addend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> SubtractOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvmaddwod_h_bu_u8 (uint16x16_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: XVMADDWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// 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<ushort> MultiplyWideningUpperAndAdd(Vector256<ushort> addend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> SubtractOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmaddwod_w_h_s16 (int32x8_t a, int16x16_t b, int16x16_t c)
-        ///   LASX: XVMADDWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// int8x32_t xvssub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSSUB.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> MultiplyWideningUpperAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvmaddwod_w_hu_u16 (uint32x8_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: XVMADDWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// uint8x32_t xvssub_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSSUB.BU Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<uint> MultiplyWideningUpperAndAdd(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmaddwod_d_w_s32 (int64x4_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// int16x16_t xvssub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSSUB.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<long> MultiplyWideningUpperAndAdd(Vector256<long> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvmaddwod_d_wu_u32 (uint64x4_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// uint16x16_t xvssub_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSSUB.HU Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvseq_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// int32x8_t xvssub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSSUB.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvseq_b_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// uint32x8_t xvssub_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSSUB.WU Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvseq_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvssub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSSUB.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> SubtractSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvseq_h_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// uint64x4_t xvssub_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSSUB.DU Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> SubtractSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvseq_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// int8x32_t xvmul_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvseq_w_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSEQ.W Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvmul_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> Multiply(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvseq_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// int16x16_t xvmul_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Multiply(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvseq_d_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16_t xvmul_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Multiply(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvfcmp_ceq_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFCMP.CEQ.S Xd.8S, Xj.8S, Xk.8S
+        /// int32x8_t xvmul_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULW Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvfcmp_ceq_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFCMP.CEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvmul_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUL.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvslt_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// int64x4_t xvmul_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Multiply(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvslt_bu_s8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// uint64x4_t xvmul_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Multiply(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvslt_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// float32x8_t xvfmul_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMUL.S Xd.8S, Xj.8S, Xk.8S
         /// </summary>
-        public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvslt_hu_s16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// float64x4_t xvfmul_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMUL.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslt_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// int8x32_t xvmuh_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUH.B Vd.32B, Vj.32B, Vk.32B
         /// </summary>
-        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> MultiplyHight(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslt_wu_s32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvmuh_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUH.BU Vd.32B, Vj.32B, Vk.32B
         /// </summary>
-        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> MultiplyHight(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvslt_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// int16x16_t xvmuh_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUH.H Vd.16H, Vj.16H, Vk.16H
         /// </summary>
-        public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> MultiplyHight(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvslt_du_s64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16_t xvmuh_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUH.HU Vd.16H, Vj.16H, Vk.16H
         /// </summary>
-        public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> MultiplyHight(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvfcmp_clt_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// int32x8_t xvmuh_w(int32x8_t a, int32x8_t b)
+        ///   LASX: VMUL.W Vd.8W, Vj.8W, Vk.8W
         /// </summary>
-        public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> MultiplyHight(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvfcmp_clt_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvmuh_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUH.WU Vd.8W, Vj.8W, Vk.8W
         /// </summary>
-        public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> MultiplyHight(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsle_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// int64x4_t xvmuh_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUH.D Vd.4D, Vj.4D, Vk.4D
         /// </summary>
-        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> MultiplyHight(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsle_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// uint64x4_t xvmuh_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUH.DU Vd.4D, Vj.4D, Vk.4D
         /// </summary>
-        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> MultiplyHight(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsle_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// int8x32_t xvdiv_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVDIV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> Divide(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsle_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// uint8x32_t xvdiv_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVDIV.BU Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> Divide(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsle_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// int16x16_t xvdiv_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVDIV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Divide(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint16x16_t xvdiv_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVDIV.HU Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Divide(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsle_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// int32x8_t xvdiv_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVDIV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsle_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvdiv_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvfcmp_cle_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// int64x4_t xvdiv_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVDIV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Divide(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvfcmp_cle_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// uint64x4_t xvdiv_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVDIV.DU Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Divide(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsle_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// float32x8_t xvfdiv_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFDIV.S Xd.8S, Xj.8S, Xk.8S
         /// </summary>
-        public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsle_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// float64x4_t xvfdiv_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFDIV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsle_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// int8x32_t xvmod_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMOD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> Modulo(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsle_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// uint8x32_t xvmod_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMOD.BU Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> Modulo(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsle_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLE.W Xd.8S, Xj.8S, Xk.8S
+        /// int16x16_t xvmod_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMOD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Modulo(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsle_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLE.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint16x16_t xvmod_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMOD.HU Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Modulo(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsle_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// int32x8_t xvmod_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMOD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Modulo(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsle_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvmod_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMOD.WU Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Modulo(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvfcmp_cle_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// int64x4_t xvmod_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMOD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Modulo(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvfcmp_cle_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// uint64x4_t xvmod_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMOD.DU Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Modulo(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvslt_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// 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<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> FusedMultiplyAdd(Vector256<float> left, Vector256<float> right, Vector256<float> addend) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvslt_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// 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<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> FusedMultiplyAdd(Vector256<double> left, Vector256<double> right, Vector256<double> addend) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvslt_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> RoundToZero(Vector256<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslt_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSLT.W Xd.8S, Xj.8S, Xk.8S
+        /// float32x8_t xvfrintrm_s(float32x8_t a)
+        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
         /// </summary>
-        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslt_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSLT.WU Xd.8S, Xj.8S, Xk.8S
+        /// float64x4_t xvfrintrm_d(float64x4_t a)
+        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvslt_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// float32x8_t xvfrintrp_s(float32x8_t a)
+        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
         /// </summary>
-        public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvslt_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// float64x4_t xvfrintrp_d(float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvfcmp_clt_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// int32x8_t xvinsgr2vr_w(int32x8_t v, int32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
         /// </summary>
-        public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Insert(Vector256<int> vector, int data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvfcmp_clt_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvinsgr2vr_w(uint32x8_t v, uint32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
         /// </summary>
-        public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Insert(Vector256<uint> vector, uint data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvmax_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVMAX.B Xd.32B, Xj.32B, Xk.32B
+        /// int64x4_t xvinsgr2vr_d(int64x4_t v, int64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
         /// </summary>
-        public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Insert(Vector256<long> vector, long data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvmax_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVMAX.BU Xd.32B, Xj.32B, Xk.32B
+        /// uint64x4_t xvinsgr2vr_d(uint64x4_t v, uint64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
         /// </summary>
-        public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Insert(Vector256<ulong> vector, ulong data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmax_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVMAX.H Xd.16H, Xj.16H, Xk.16H
+        /// 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<short> Max(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Insert(Vector256<float> vector, float data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvmax_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVMAX.HU Xd.16H, Xj.16H, Xk.16H
+        /// 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<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Insert(Vector256<double> vector, double data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmax_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMAX.W Xd.8S, Xj.8S, Xk.8S
+        /// int8x32_t xvreplgr2vr_b(int8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
         /// </summary>
-        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> DuplicateToVector256(sbyte value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvmax_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMAX.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvreplgr2vr_b(uint8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
         /// </summary>
-        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> DuplicateToVector256(byte value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmax_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVMAX.D Xd.8S, Xj.8S, Xk.8S
+        /// int16x16_t xvreplgr2vr_h(int16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
         /// </summary>
-        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> DuplicateToVector256(short value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvmax_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVMAX.DU Xd.8S, Xj.8S, Xk.8S
+        /// uint16x16_t xvreplgr2vr_h(uint16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
         /// </summary>
-        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> DuplicateToVector256(ushort value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfmax_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFMAX.S Xd.8S, Xj.8S, Xk.8S
+        /// int32x8_t xvreplgr2vr_w(int32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
         /// </summary>
-        public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> DuplicateToVector256(int value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfmax_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFMAX.d Xd.4D, Xj.4D, Xk.4D
+        /// uint32x8_t xvreplgr2vr_w(uint32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
         /// </summary>
-        public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> DuplicateToVector256(uint value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvmin_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVMIN.B Xd.32B, Xj.32B, Xk.32B
+        /// int64x4_t xvreplgr2vr_d(int64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
         /// </summary>
-        public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> DuplicateToVector256(long value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvmin_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVMIN.BU Xd.32B, Xj.32B, Xk.32B
+        /// uint64x4_t xvreplgr2vr_d(uint64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
         /// </summary>
-        public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> DuplicateToVector256(ulong value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmin_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVMIN.H Xd.16H, Xj.16H, Xk.16H
+        /// float32x8_t xvreplve0_w(float32_t value)
+        ///   LASX: XVREPLVE0.W Xd.8S, Xj.S[0]
         /// </summary>
-        public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> DuplicateToVector256(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvmin_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVMIN.HU Xd.16H, Xj.16H, Xk.16H
+        /// float64x4_t xvreplve0_d(float64_t value)
+        ///   LASX: XVREPLVE0.D Xd.4D, Xj.D[0]
         /// </summary>
-        public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> DuplicateToVector256(double value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmin_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMIN.W Xd.8S, Xj.8S, Xk.8S
+        /// float32x8_t xvffint_s_w(int32x8_t a)
+        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8W
         /// </summary>
-        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> ConvertToSingle(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvmin_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMIN.WU Xd.8S, Xj.8S, Xk.8S
+        /// float32x8_t xvffint_s_wu(uint32x8_t a)
+        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8W
         /// </summary>
-        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> ConvertToSingle(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmin_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVMIN.D Xd.8S, Xj.8S, Xk.8S
+        /// float64x4_t xvffint_d_l(int64x4_t a)
+        ///   LASX: XVFFINT.D.L Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> ConvertToDouble(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvmin_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVMIN.DU Xd.8S, Xj.8S, Xk.8S
+        /// float64x4_t xvffint_d_lu(uint64x4_t a)
+        ///   LASX: XVFFINT.D.LU Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> ConvertToDouble(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfmin_s_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVFMIN.S Xd.8S, Xj.8S, Xk.8S
+        /// bool xvsetnez_v(uint8x32_t value)
+        ///   LASX: XVSETNEZ.V cd, Xj.32B
         /// </summary>
-        public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfmin_d_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVFMIN.D Xd.4D, Xj.4D, Xk.4D
+        /// bool xvseteqz_v(uint8x32_t value)
+        ///   LASX: XVSETEQZ.V cd, Xj.32B
         /// </summary>
-        public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvbitsel_v_s8 (uint8x32_t a, int8x32_t b, int8x32_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_b(int8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
         /// </summary>
-        public static Vector256<sbyte> BitwiseSelect(Vector256<sbyte> select, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvbitsel_v_u8 (uint8x32_t a, uint8x32_t b, uint8x32_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_b(uint8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
         /// </summary>
-        public static Vector256<byte> BitwiseSelect(Vector256<byte> select, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvbitsel_v_s16 (uint16x16_t a, int16x16_t b, int16x16_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_h(int16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
         /// </summary>
-        public static Vector256<short> BitwiseSelect(Vector256<short> select, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvbitsel_v_u16 (uint16x16_t a, uint16x16_t b, uint16x16_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_h(uint16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
         /// </summary>
-        public static Vector256<ushort> BitwiseSelect(Vector256<ushort> select, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvbitsel_v_s32 (uint32x8_t a, int32x8_t b, int32x8_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_w(int32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
         /// </summary>
-        public static Vector256<int> BitwiseSelect(Vector256<int> select, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvbitsel_v_u32 (uint32x8_t a, uint32x8_t b, uint32x8_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_w(uint32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
         /// </summary>
-        public static Vector256<uint> BitwiseSelect(Vector256<uint> select, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvbitsel_v_s64 (uint64x4_t a, int64x4_t b, int64x4_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_w(int64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
         /// </summary>
-        public static Vector256<long> BitwiseSelect(Vector256<long> select, Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvbitsel_v_u64 (uint64x4_t a, uint64x4_t b, uint64x4_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetallnez_w(uint64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
         /// </summary>
-        public static Vector256<ulong> BitwiseSelect(Vector256<ulong> select, Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvbitsel_v_f32 (uint32x8_t a, float32x8_t b, float32x8_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetanyeqz_b(int8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
         /// </summary>
-        public static Vector256<float> BitwiseSelect(Vector256<float> select, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvbitsel_v_f64 (uint64x4_t a, float64x4_t b, float64x4_t c)
-        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetanyeqz_b(uint8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
         /// </summary>
-        public static Vector256<double> BitwiseSelect(Vector256<double> select, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvabsd_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVABSD.B Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetanyeqz_h(int16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
         /// </summary>
-        public static Vector256<byte> AbsoluteDifference(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvabsd_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVABSD.BU Xd.32B, Xj.32B, Xk.32B
+        /// bool xvsetanyeqz_h(uint16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
         /// </summary>
-        public static Vector256<byte> AbsoluteDifference(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvabsd_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVABSD.H Xd.16H, Xj.16H, Xk.16H
+        /// bool xvsetanyeqz_w(int32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
         /// </summary>
-        public static Vector256<ushort> AbsoluteDifference(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvabsd_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVABSD.HU Xd.16H, Xj.16H, Xk.16H
+        /// bool xvsetanyeqz_w(uint32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
         /// </summary>
-        public static Vector256<ushort> AbsoluteDifference(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvabsd_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVABSD.W Xd.8S, Xj.8S, Xk.8S
+        /// bool xvsetanyeqz_w(int64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
         /// </summary>
-        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvabsd_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVABSD.WU Xd.8S, Xj.8S, Xk.8S
+        /// bool xvsetanyeqz_w(uint64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
         /// </summary>
-        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvabsd_d_s64 (uint64x4_t a, int64x4_t b, int64x4_t c)
-        ///   LASX: XVABSD.D Xd.32B, Xj.32B, Xk.32B
+        /// int8x32 xvsrlni_b_h(int16x16_t left, int16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
         /// </summary>
-        public static Vector256<ulong> AbsoluteDifference(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvabsd_du_u64 (uint64x4_t a, uint64x4_t b, uint64x4_t c)
-        ///   LASX: XVABSD.DU Xd.32B, Xj.32B, Xk.32B
+        /// uint8x32 xvsrlni_b_h(uint16x16_t left, uint16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
         /// </summary>
-        public static Vector256<ulong> AbsoluteDifference(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t TODO_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        /// int16x16 xvsrlni_h_w(int32x8_t left, int32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
         /// </summary>
-        public static Vector256<float> AbsoluteDifference(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t TODO_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16 xvsrlni_h_w(uint32x8_t left, uint32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
         /// </summary>
-        public static Vector256<double> AbsoluteDifference(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvld_s8 (int8_t const * ptr)
-        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// int32x8 xvsrlni_w_d(int64x4_t left, int64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
         /// </summary>
-        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvld_u8 (uint8_t const * ptr)
-        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// uint32x8 xvsrlni_w_d(uint64x4_t left, uint64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
         /// </summary>
-        public static unsafe Vector256<byte> LoadVector256(byte* address) { throw new PlatformNotSupportedException(); }
+        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>
-        /// int16x16_t xvld_s16 (int16_t const * ptr)
-        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// uint8x16_t xvsrln_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLN.B.H Xd.8B, Xj.16H, Xk.16H
         /// </summary>
-        public static unsafe Vector256<short> LoadVector256(short* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvld_s16 (uint16_t const * ptr)
-        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// int16x8_t xvsrln_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static unsafe Vector256<ushort> LoadVector256(ushort* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvld_s32 (int32_t const * ptr)
-        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// uint16x8_t xvsrln_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static unsafe Vector256<int> LoadVector256(int* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvld_s32 (uint32_t const * ptr)
-        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// int32x4_t xvsrln_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
         /// </summary>
-        public static unsafe Vector256<uint> LoadVector256(uint* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvld_s64 (int64_t const * ptr)
-        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// uint32x4_t xvsrln_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
         /// </summary>
-        public static unsafe Vector256<long> LoadVector256(long* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvld_u64 (uint64_t const * ptr)
-        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// 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 unsafe Vector256<ulong> LoadVector256(ulong* address) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvld_f32 (float32_t const * ptr)
-        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// 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 unsafe Vector256<float> LoadVector256(float* address) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvld_f64 (float64_t const * ptr)
-        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// 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 unsafe Vector256<double> LoadVector256(double* address) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrecip_s_f32 (float32x8_t a)
-        ///   LASX: XVFRECIP.S Xd.8S Xj.8S
+        /// 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<float> Reciprocal(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrecip_d_f64 (float64x4_t a)
-        ///   LASX: XVFRECIP.D Xd.4D Xj.4D
+        /// 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<double> Reciprocal(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrsqrt_s_f32 (float32x8_t a)
-        ///   LASX: XVFRSQRT.S Xd.8S Xj.8S
+        /// 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<float> ReciprocalSqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrsqrt_d_f64 (float64x4_t a)
-        ///   LASX: XVFRSQRT.D Xd.4D Xj.4D
+        /// 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<double> ReciprocalSqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_s8 (int8_t * ptr, int8x32_t val)
-        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// int8x16_t xvssrlrn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
         /// </summary>
-        public static unsafe void Store(sbyte* address, Vector256<sbyte> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_u8 (uint8_t * ptr, uint8x32_t val)
-        ///   LASX: XVST { Xd.32B }, Rj, si12
+        /// uint8x16_t xvssrlrn_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
         /// </summary>
-        public static unsafe void Store(byte* address, Vector256<byte> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_s16 (int16_t * ptr, int16x16_t val)
-        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// int16x4_t xvssrlrn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static unsafe void Store(short* address, Vector256<short> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_u16 (uint16_t * ptr, uint16x16_t val)
-        ///   LASX: XVST { Xd.16H }, Rj, si12
+        /// uint16x4_t xvssrlrn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static unsafe void Store(ushort* address, Vector256<ushort> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_s32 (int32_t * ptr, int32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// int32x4_t xvssrlrn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static unsafe void Store(int* address, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_u32 (uint32_t * ptr, uint32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// uint32x4_t xvssrlrn_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static unsafe void Store(uint* address, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_s64 (int64_t * ptr, int64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// 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 unsafe void Store(long* address, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_u64 (uint64_t * ptr, uint64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// 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 unsafe void Store(ulong* address, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_f32 (float32_t * ptr, float32x8_t val)
-        ///   LASX: XVST { Xd.8S }, Rj, si12
+        /// 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 unsafe void Store(float* address, Vector256<float> source) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void xvst_f64 (float64_t * ptr, float64x4_t val)
-        ///   LASX: XVST { Xd.4D }, Rj, si12
+        /// uint8x16_t xvssrlrn_bu_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.BU.H Xd.16B, Xj.16H, Xk.16H
         /// </summary>
-        public static unsafe void Store(double* address, Vector256<double> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvneg_b_s8 (int8x32_t a)
-        ///   LASX: XVNEG.B Xd.32B, Xj.32B
+        /// uint16x4_t xvssrlrn_hu_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.HU.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<sbyte> Negate(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvneg_h_s16 (int16x16_t a)
-        ///   LASX: XVNEG.H Xd.16H, Xj.16H
+        /// uint32x4_t xvssrlrn_wu_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.WU.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> Negate(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvneg_w_s32 (int32x8_t a)
-        ///   LASX: XVNEG.W Xd.8S, Xj.8S
+        /// 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<int> Negate(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvneg_d_s64 (int64x4_t a)
-        ///   LASX: XVNEG.D Xd.4D, Xj.4D
+        /// 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<long> Negate(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t TODO_f32 (float32x8_t a)
-        ///   LASX: TODO Xd.8S, Xj.8S
+        /// 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<float> Negate(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t TODO_f64 (float64x4_t a)
-        ///   LASX: TODO Xd.4D, Xj.4D
+        /// int8x16_t xvssrarn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.B.H Xd.16B, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<double> Negate(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfmsub_s_f32 (float32x8_t a, float32x8_t b, float32x8_t c)
-        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// int16x4_t xvssrarn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.H.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<float> FusedMultiplySubtract(Vector256<float> minuend, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfmsub_d_f64 (float64x4_t a, float64x4_t b, float64x4_t c)
-        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// int32x4_t xvssrarn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.W.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<double> FusedMultiplySubtract(Vector256<double> minuend, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvmulwod_h_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// 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<short> MultiplyWideningUpper(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvmulwod_h_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// 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> MultiplyWideningUpper(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvmulwod_w_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVMULWOD.W.H Xd.8S, Xj.16H, Xk.16H
+        /// 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<int> MultiplyWideningUpper(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvmulwod_w_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVMULWOD.W.HU Xd.8S, Xj.16H, Xk.16H
+        /// uint8x16_t xvssrarn_bu_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.BU.H Xd.16B, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> MultiplyWideningUpper(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvmulwod_d_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8S, Xk.8S
+        /// uint16x8_t xvssrarn_hu_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.HU.W Xd.8H, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> MultiplyWideningUpper(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvmulwod_d_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8S, Xk.8S
+        /// uint32x4_t xvssrarn_wu_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.WU.D Xd.4W, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ulong> MultiplyWideningUpper(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvssub_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVSSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// int8x32_t xvclo_b(int8x32_t a)
+        ///   LASX: XVCLO.B Xd.32B, Xj.32B
         /// </summary>
-        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> LeadingSignCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvssub_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVSSUB.BU Xd.32B, Xj.32B, Xk.32B
+        /// int16x16_t xvclo_h(int16x16_t a)
+        ///   LASX: XVCLO.H Xd.16H, Xj.16H
         /// </summary>
-        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> LeadingSignCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvssub_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVSSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// int32x8_t xvclo_w(int32x8_t a)
+        ///   LASX: XVCLO.W Xd.8W, Xj.8W
         /// </summary>
-        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> LeadingSignCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvssub_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVSSUB.HU Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvclo_d(int64x4_t a)
+        ///   LASX: XVCLO.D Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> LeadingSignCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvssub_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVSSUB.W Xd.8S, Xj.8S, Xk.8S
+        /// int8x32_t xvclz_b(int8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
         /// </summary>
-        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> LeadingZeroCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvssub_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVSSUB.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvclz_b(uint8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
         /// </summary>
-        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> LeadingZeroCount(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvssub_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVSSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// int16x16_t xvclz_h(int16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
         /// </summary>
-        public static Vector256<long> SubtractSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> LeadingZeroCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvssub_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVSSUB.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16_t xvclz_h(uint16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
         /// </summary>
-        public static Vector256<ulong> SubtractSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> LeadingZeroCount(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvavg_b_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVAVG.B Xd.32B, Xj.32B, Xk.32B
+        /// int32x8_t xvclz_w(int32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
         /// </summary>
-        public static Vector256<sbyte> Average(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> LeadingZeroCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvavg_bu_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVAVG.BU Xd.32B, Xj.32B, Xk.32B
+        /// uint32x8_t xvclz_w(uint32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
         /// </summary>
-        public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> LeadingZeroCount(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvavg_h_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVAVG.H Xd.16H, Xj.16H, Xk.16H
+        /// int64x4_t xvclz_d(int64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<short> Average(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> LeadingZeroCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvavg_hu_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVAVG.HU Xd.16H, Xj.16H, Xk.16H
+        /// uint64x4_t xvclz_d(uint64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
         /// </summary>
-        public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvavg_w_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVAVG.W Xd.8S, Xj.8S, Xk.8S
+        /// int8x32_t xvpcnt_b(int8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
         /// </summary>
-        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvavg_wu_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVAVG.WU Xd.8S, Xj.8S, Xk.8S
+        /// uint8x32_t xvpcnt_b(uint8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
         /// </summary>
-        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> PopCount(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvavg_d_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVAVG.D Xd.4D, Xj.4D, Xk.4D
+        /// int16x16_t xvpcnt_h(int16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
         /// </summary>
-        public static Vector256<long> Average(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> PopCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvavg_du_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVAVG.DU Xd.4D, Xj.4D, Xk.4D
+        /// uint16x16_t xvpcnt_h(uint16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
         /// </summary>
-        public static Vector256<ulong> Average(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> PopCount(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvexth_h_b_s8 (int8x32_t a)
-        ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        /// int32x8_t xvpcnt_w(int32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
         /// </summary>
-        public static Vector256<short> SignExtendWideningUpper(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> PopCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvexth_w_h_s16 (int16x16_t a)
-        ///   LASX: XVEXTH.W.H Xd.8S, Xj.16H
+        /// uint32x8_t xvpcnt_w(uint32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
         /// </summary>
-        public static Vector256<int> SignExtendWideningUpper(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> PopCount(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvexth_d_w_s32 (int32x8_t a)
-        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8S
+        /// int64x4_t xvpcnt_d(int64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
         /// </summary>
-        public static Vector256<long> SignExtendWideningUpper(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> PopCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
-        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// uint64x4_t xvpcnt_d(uint64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
         /// </summary>
-        public static Vector256<short> ZeroExtendWideningUpper(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> PopCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvexth_HU_BU_u8 (uint8x32_t a)
-        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        ///  int32x8_t xvperm_w(int32x8_t vec, int32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ushort> ZeroExtendWideningUpper(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorShuffle(Vector256<int> vector, Vector256<int> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
-        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        ///  uint32x8_t xvperm_w(uint32x8_t vec, uint32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<int> ZeroExtendWideningUpper(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorShuffle(Vector256<uint> vector, Vector256<uint> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvexth_WU_HU_u16 (uint16x16_t a)
-        ///   LASX: XVEXTH.WU.HU Xd.8S, Xj.16H
+        ///  int64x4_t xvpermi_w(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
         /// </summary>
-        public static Vector256<uint> ZeroExtendWideningUpper(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorShuffle(Vector256<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        ///  uint64x4_t xvpermi_w(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
         /// </summary>
-        public static Vector256<long> ZeroExtendWideningUpper(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorShuffle(Vector256<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvexth_DU_WU_u32 (uint32x8_t a)
-        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8S
+        ///  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<ulong> ZeroExtendWideningUpper(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+        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>
-        /// int8x32_t xvand_v_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector0, Vector256<byte> vector1, Vector256<byte> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvand_v_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<byte> And(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        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 xvand_v_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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> And(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorShuffleEach128(Vector256<short> vector0, Vector256<short> vector1, Vector256<short> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvand_v_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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> And(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector0, Vector256<ushort> vector1, Vector256<ushort> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvand_v_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  int32x8_t xvpermi_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<int> And(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvand_v_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint32x8_t xvpermi_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvand_v_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<long> And(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector0, Vector256<int> vector1, Vector256<int> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvand_v_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<ulong> And(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector0, Vector256<uint> vector1, Vector256<uint> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvand_v_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<float> And(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorShuffleEach128(Vector256<long> vector0, Vector256<long> vector1, Vector256<long> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvand_v_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        ///  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<double> And(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorShuffleEach128(Vector256<ulong> vector0, Vector256<ulong> vector1, Vector256<ulong> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvandn_v_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  int8x32_t xvshuf4i_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
         /// </summary>
-        public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorShuffleBy4Elements(Vector256<sbyte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvandn_v_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint8x32_t xvshuf4i_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
         /// </summary>
-        public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorShuffleBy4Elements(Vector256<byte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvandn_v_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  int16x16_t xvshuf4i_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
         /// </summary>
-        public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorShuffleBy4Elements(Vector256<short> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvandn_v_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint16x16_t xvshuf4i_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
         /// </summary>
-        public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorShuffleBy4Elements(Vector256<ushort> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvandn_v_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  int32x8_t xvshuf4i_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorShuffleBy4Elements(Vector256<int> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvandn_v_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint32x8_t xvshuf4i_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorShuffleBy4Elements(Vector256<uint> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvandn_v_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  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> AndNot(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorShuffleBy4Elements(Vector256<long> vector0, Vector256<long> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvandn_v_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  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> AndNot(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorShuffleBy4Elements(Vector256<ulong> vector0, Vector256<ulong> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvandn_v_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  int8x32_t xvilvl_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementsFusionLowerEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvandn_v_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint8x32_t xvilvl_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementsFusionLowerEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvor_v_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int16x16_t xvilvl_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementsFusionLowerEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvor_v_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint16x16_t xvilvl_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementsFusionLowerEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvor_v_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int32x8_t xvilvl_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementsFusionLowerEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvor_v_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint32x8_t xvilvl_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementsFusionLowerEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvor_v_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int64x4_t xvilvl_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementsFusionLowerEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvor_v_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint64x4_t xvilvl_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementsFusionLowerEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvor_v_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int8x32_t xvilvh_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementsFusionHightEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvor_v_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint8x32_t xvilvh_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementsFusionHightEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvor_v_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int16x16_t xvilvh_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementsFusionHightEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvor_v_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint16x16_t xvilvh_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementsFusionHightEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvxor_v_s8 (int8x32_t a, int8x32_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int32x8_t xvilvh_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementsFusionHightEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvxor_v_u8 (uint8x32_t a, uint8x32_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint32x8_t xvilvh_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementsFusionHightEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvxor_v_s16 (int16x16_t a, int16x16_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int64x4_t xvilvh_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementsFusionHightEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvxor_v_u16 (uint16x16_t a, uint16x16_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint64x4_t xvilvh_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementsFusionHightEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvxor_v_s32 (int32x8_t a, int32x8_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int8x32_t xvpackev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementsFusionEven(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvxor_v_u32 (uint32x8_t a, uint32x8_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint8x32_t xvpackev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementsFusionEven(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvxor_v_s64 (int64x4_t a, int64x4_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int16x16_t xvpackev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementsFusionEven(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvxor_v_u64 (uint64x4_t a, uint64x4_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint16x16_t xvpackev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementsFusionEven(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvxor_v_f32 (float32x8_t a, float32x8_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  int32x8_t xvpackev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementsFusionEven(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvxor_v_f64 (float64x4_t a, float64x4_t b)
-        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        ///  uint32x8_t xvpackev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementsFusionEven(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvslli_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        ///  int64x4_t xvpackev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementsFusionEven(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvslli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, #n
+        ///  uint64x4_t xvpackev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementsFusionEven(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvslli_h_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        ///  int8x32_t xvpackod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementsFusionOdd(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvslli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, #n
+        ///  uint8x32_t xvpackod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementsFusionOdd(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslli_w_s32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        ///  int16x16_t xvpackod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementsFusionOdd(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvslli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSLLI.W Xd.8S, Xj.8S, #n
+        ///  uint16x16_t xvpackod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementsFusionOdd(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvslli_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        ///  int32x8_t xvpackod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementsFusionOdd(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvslli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, #n
+        ///  uint32x8_t xvpackod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementsFusionOdd(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        ///  int64x4_t xvpackod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementsFusionOdd(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsrli_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, #n
+        ///  uint64x4_t xvpackod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementsFusionOdd(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        ///  int8x32_t xvpickev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorEvenElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsrli_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, #n
+        ///  uint8x32_t xvpickev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorEvenElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        ///  int16x16_t xvpickev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorEvenElementsJoinEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsrli_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLI.W Xd.8S, Xj.8S, #n
+        ///  uint16x16_t xvpickev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorEvenElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        ///  int32x8_t xvpickev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorEvenElementsJoinEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsrli_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, #n
+        ///  uint32x8_t xvpickev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorEvenElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        ///  int64x4_t xvpickev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorEvenElementsJoinEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvsrlri_b_u8 (uint8x32_t a, const int n)
-        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, #n
+        ///  uint64x4_t xvpickev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorEvenElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        ///  int8x32_t xvpickod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorOddElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvsrlri_h_u16 (uint16x16_t a, const int n)
-        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, #n
+        ///  uint8x32_t xvpickod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorOddElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        ///  int16x16_t xvpickod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorOddElementsJoinEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvsrlri_w_u32 (uint32x8_t a, const int n)
-        ///   LASX: XVSRLRI.W Xd.8S, Xj.8S, #n
+        ///  uint16x16_t xvpickod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorOddElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        ///  int32x8_t xvpickod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorOddElementsJoinEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvsrlri_d_u64 (uint64x4_t a, const int n)
-        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, #n
+        ///  uint32x8_t xvpickod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorOddElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvsrai_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, #n
+        ///  int64x4_t xvpickod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorOddElementsJoinEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvsrai_h_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, #n
+        ///  uint64x4_t xvpickod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorOddElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvsrai_w_s32 (int32x8_t a, const int n)
-        ///   LASX: XVSRAI.W Xd.8S, Xj.8S, #n
+        ///  uint8x32_t xvrepl128vei(uint8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
         /// </summary>
-        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementReplicateEach128(Vector256<byte> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvsrai_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, #n
+        ///  int8x32_t xvrepl128vei(int8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
         /// </summary>
-        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementReplicateEach128(Vector256<sbyte> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvsrari_b_s8 (int8x32_t a, const int n)
-        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, #n
+        ///  int16x16_t xvrepl128vei(int16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
         /// </summary>
-        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementReplicateEach128(Vector256<short> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvsrari_h_s16 (int16x16_t a, const int n)
-        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, #n
+        ///  uint16x16_t xvrepl128vei(uint16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
         /// </summary>
-        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementReplicateEach128(Vector256<ushort> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvsrari_w_s32 (int32x8_t a, const int n)
-        ///   LASX: XVSRARI.W Xd.8S, Xj.8S, #n
+        ///  int32x8_t xvrepl128vei(int32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
         /// </summary>
-        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementReplicateEach128(Vector256<int> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvsrari_d_s64 (int64x4_t a, const int n)
-        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, #n
+        ///  uint32x8_t xvrepl128vei(uint32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
         /// </summary>
-        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementReplicateEach128(Vector256<uint> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvadda_b_s8 (int8x32_t a)
-        ///   LASX: XVADDA.B Xd.32B, Xd.32B, 0
+        ///  int64x4_t xvrepl128vei(int64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
         /// </summary>
-        public static Vector256<byte> Abs(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementReplicateEach128(Vector256<long> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvadda_h_s16 (int16x16_t a)
-        ///   LASX: XVADDA.H Xd.16H, Xd.16H, 0
+        ///  uint64x4_t xvrepl128vei(uint64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
         /// </summary>
-        public static Vector256<ushort> Abs(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementReplicateEach128(Vector256<ulong> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvadda_w_s32 (int32x8_t a)
-        ///   LASX: XVADDA.W Xd.8S, Xd.8S, 0
+        ///  int8x32_t xvextrins_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
         /// </summary>
-        public static Vector256<uint> Abs(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<sbyte> UpdateOneVectorElementEach128(Vector258<sbyte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvadda_d_s64 (int64xx_t a)
-        ///   LASX: XVADDA.D Xd.4D, Xd.4D, 0
+        ///  uint8x32_t xvextrins_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
         /// </summary>
-        public static Vector256<ulong> Abs(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<byte> UpdateOneVectorElementEach128(Vector258<byte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvbitclri_w_f32 (float32x8_t a)
-        ///   LASX: XVBITCLRI.W Xd.8S, Xd.8S, 31
+        ///  int16x16_t xvextrins_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
         /// </summary>
-        public static Vector256<float> Abs(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<short> UpdateOneVectorElementEach128(Vector258<short> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvbitclri_d_f64 (float64x4_t a)
-        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, 63
+        ///  uint16x16_t xvextrins_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
         /// </summary>
-        public static Vector256<double> Abs(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<ushort> UpdateOneVectorElementEach128(Vector258<ushort> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfsqrt_s_f32 (float32x8_t a)
-        ///   LASX: XVFSQRT.S Xd.8S, Xj.8S
+        ///  int32x8_t xvextrins_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<float> Sqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<int> UpdateOneVectorElementEach128(Vector258<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfsqrt_d_f64 (float64x4_t a)
-        ///   LASX: XVFSQRT.D Xd.4D, Xj.4D
+        ///  uint32x8_t xvextrins_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
         /// </summary>
-        public static Vector256<double> Sqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<uint> UpdateOneVectorElementEach128(Vector258<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrintrm_s_f32 (float32x8_t a)
-        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        ///  int64x4_t xvextrins_d(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
         /// </summary>
-        public static Vector256<float> Floor(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<long> UpdateOneVectorElementEach128(Vector258<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrintrm_d_f64 (float64x4_t a)
-        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        ///  uint64x4_t xvextrins_d(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
         /// </summary>
-        public static Vector256<double> Floor(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<ulong> UpdateOneVectorElementEach128(Vector258<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrintrp_s_f32 (float32x8_t a)
-        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        ///  int8x32_t xvsigncov_b(int8x32_t sign, int8x32_t data)
+        ///   LASX: XVSIGNCOV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<float> Ceiling(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<sbyte> VectorElementNegatedBySign(Vector258<sbyte> sign, Vector258<sbyte> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrintrp_d_f64 (float64x4_t a)
-        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        ///  int16x16_t xvsigncov_h(int16x16_t sign, int16x16_t data)
+        ///   LASX: XVSIGNCOV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<double> Ceiling(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<short> VectorElementNegatedBySign(Vector258<short> sign, Vector258<short> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrintrz_s_f32 (float32x8_t a)
-        ///   LASX: XVFRINTRZ.S Xd.8S, Xj.8S
+        ///  int32x8_t xvsigncov_w(int32x8_t sign, int32x8_t data)
+        ///   LASX: XVSIGNCOV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<float> RoundToZero(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<int> VectorElementNegatedBySign(Vector258<int> sign, Vector258<int> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrintrz_d_f64 (float64x4_t a)
-        ///   LASX: XVFRINTRZ.D Xd.4D, Xj.4D
+        ///  int64x4_t xvsigncov_d(int64x4_t sign, int64x4_t data)
+        ///   LASX: XVSIGNCOV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<double> RoundToZero(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector258<long> VectorElementNegatedBySign(Vector258<long> sign, Vector258<long> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrintrm_s_f32 (float32x8_t a)
-        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        /// int8x32_t xvbitclri_b(int8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrintrm_d_f64 (float64x4_t a)
-        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        /// uint8x32_t xvbitclri_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvfrintrp_s_f32 (float32x8_t a)
-        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        /// int16x16_t xvbitclri_h(int16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvfrintrp_d_f64 (float64x4_t a)
-        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// uint16x16_t xvbitclri_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t TODO_s8 (int8_t a, int8x32_t v, const int imm)
-        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
         /// </summary>
-        public static Vector256<sbyte> Insert(Vector256<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t TODO_u8 (uint8_t a, uint8x32_t v, const int imm)
-        ///   LASX: TODO Xd.B[imm], Rj, imm
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
         /// </summary>
-        public static Vector256<byte> Insert(Vector256<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t TODO_s16 (int16_t a, int16x16_t v, const int imm)
-        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// int64x4_t xvbitclri_d(int64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<short> Insert(Vector256<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t TODO_u16 (uint16_t a, uint16x16_t v, const int imm)
-        ///   LASX: TODO Xd.H[imm], Rj, imm
+        /// uint64x4_t xvbitclri_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<ushort> Insert(Vector256<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvinsgr2vr_w_s32 (int32_t a, int32x8_t v, const int imm)
-        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// int8x32_t xvbitclr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<int> Insert(Vector256<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvinsgr2vr_w_u32 (uint32_t a, uint32x8_t v, const int imm)
-        ///   LASX: XVINSGR2VR.W Xd.S[imm], Rj, imm
+        /// uint8x32_t xvbitclr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<uint> Insert(Vector256<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvinsgr2vr_d_s64 (int64_t a, int64x4_t v, const int imm)
-        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// int16x16_t xvbitclr_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<long> Insert(Vector256<long> vector, byte index, long data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvinsgr2vr_d_u64 (uint64_t a, uint64x4_t v, const int imm)
-        ///   LASX: XVINSGR2VR.D Xd.D[imm], Rj, imm
+        /// uint16x16_t xvbitclr_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ulong> Insert(Vector256<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvinsve0_w_f32 (float32_t a, float32x8_t v, const int imm)
-        ///   LASX: XVINSVE0.W Xd.S[imm], Xj.S[0], imm
+        /// int32x8_t xvbitclr_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<float> Insert(Vector256<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvinsve0_d_f64 (float64_t a, float64x4_t v, const int imm)
-        ///   LASX: XVINSVE0.D Xd.D[imm], Xj.D[0], imm
+        /// uint32x8_t xvbitclr_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static Vector256<double> Insert(Vector256<double> vector, byte index, double data) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvreplgr2vr_b_s8 (int8_t value)
-        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// int64x4_t xvbitclr_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> DuplicateToVector256(sbyte value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvreplgr2vr_b_u8 (uint8_t value)
-        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// uint64x4_t xvbitclr_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> DuplicateToVector256(byte value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvreplgr2vr_h_s16 (int16_t value)
-        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// int8x32_t xvbitseti_b(int8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<short> DuplicateToVector256(short value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvreplgr2vr_h_u16 (uint16_t value)
-        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// uint8x32_t xvbitseti_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static Vector256<ushort> DuplicateToVector256(ushort value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvreplgr2vr_w_s32 (int32_t value)
-        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// int16x16_t xvbitseti_h(int16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<int> DuplicateToVector256(int value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvreplgr2vr_w_u32 (uint32_t value)
-        ///   LASX: XVREPLGR2VR.W Xd.8S, Rj
+        /// uint16x16_t xvbitseti_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static Vector256<uint> DuplicateToVector256(uint value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvreplgr2vr_d_s64 (int64_t value)
-        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
         /// </summary>
-        public static Vector256<long> DuplicateToVector256(long value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvreplgr2vr_d_u64 (uint64_t value)
-        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
         /// </summary>
-        public static Vector256<ulong> DuplicateToVector256(ulong value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvreplve0_w_f32 (float32_t value)
-        ///   LASX: XVREPLVE0.W Xd.8S, Xj.S[0]
+        /// int64x4_t xvbitseti_d(int64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<float> DuplicateToVector256(float value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvreplve0_d_f64 (float64_t value)
-        ///   LASX: XVREPLVE0.D Xd.4D, Xj.D[0]
+        /// uint64x4_t xvbitseti_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static Vector256<double> DuplicateToVector256(double value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvffint_s_w_f32_s32 (int32x8_t a)
-        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8S
+        /// int8x32_t xvbitset_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<float> ConvertToSingle(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x8_t xvffint_s_wu_f32_u32 (uint32x8_t a)
-        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8S
+        /// uint8x32_t xvbitset_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<float> ConvertToSingle(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvffint_d_l_f64_s64 (int64x4_t a)
-        ///   LASX: XVFFINT.D.L Xd.4D, Xj.4D
+        /// int16x16_t xvbitset_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<double> ConvertToDouble(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x4_t xvffint_d_lu_f64_u64 (uint64x4_t a)
-        ///   LASX: XVFFINT.D.LU Xd.4D, Xj.4D
+        /// uint16x16_t xvbitset_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<double> ConvertToDouble(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetnez_v_u8 (uint8x32_t value)
-        ///   LASX: XVSETNEZ.V cd, Xj.32B
+        /// int32x8_t xvbitset_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static bool HasElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvseteqz_v_u8 (uint8x32_t value)
-        ///   LASX: XVSETEQZ.V cd, Xj.32B
+        /// uint32x8_t xvbitset_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static bool AllElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_b_s8 (int8x32_t value)
-        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// int64x4_t xvbitset_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_b_u8 (uint8x32_t value)
-        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// uint64x4_t xvbitset_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_h_s16 (int16x16_t value)
-        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// int8x32_t xvbitrevi_b(int8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_h_u16 (uint16x16_t value)
-        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// uint8x32_t xvbitrevi_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_w_s32 (int32x8_t value)
-        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// int16x16_t xvbitrevi_h(int16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_w_u32 (uint32x8_t value)
-        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// uint16x16_t xvbitrevi_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_w_s64 (int64x8_t value)
-        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetallnez_w_u64 (uint64x8_t value)
-        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
         /// </summary>
-        public static bool AllElementsNotZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_b_s8 (int8x32_t value)
-        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// int64x4_t xvbitrevi_d(int64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_b_u8 (uint8x32_t value)
-        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// uint64x4_t xvbitrevi_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_h_s16 (int16x16_t value)
-        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// int8x32_t xvbitrev_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_h_u16 (uint16x16_t value)
-        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// uint8x32_t xvbitrev_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_w_s32 (int32x8_t value)
-        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// int16x16_t xvbitrev_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_w_u32 (uint32x8_t value)
-        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// uint16x16_t xvbitrev_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_w_s64 (int64x8_t value)
-        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// int32x8_t xvbitrev_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool xvsetanyeqz_w_u64 (uint64x8_t value)
-        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// uint32x8_t xvbitrev_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
         /// </summary>
-        public static bool HasElementsIsZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x32_t xvpcnt_b_s8 (int8x32_t a)
-        ///   LASX: XVPCNT_B Xd, Xj
+        /// int64x4_t xvbitrev_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x32_t xvpcnt_b_u8 (uint8x32_t a)
-        ///   LASX: XVPCNT_B Xd, Xj
+        /// uint64x4_t xvbitrev_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
         /// </summary>
-        public static Vector256<byte> PopCount(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x16_t xvpcnt_h_s16 (int16x16_t a)
-        ///   LASX: XVPCNT_H Xd, Xj
+        /// int8x32_t xvfrstp_b(int8x32_t value, int8x32_t save)
+        ///   LASX: XVFRSTP.B Xd.32B, Xj.32B, Xk.32B
         /// </summary>
-        public static Vector256<short> PopCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, Vector256<sbyte> save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x16_t xvpcnt_h_u16 (uint16x16_t a)
-        ///   LASX: XVPCNT_H Xd, Xj
+        /// int16x16_t xvfrstp_h(int16x16_t value, int16x16_t save)
+        ///   LASX: XVFRSTP.H Xd.16H, Xj.16H, Xk.16H
         /// </summary>
-        public static Vector256<ushort> PopCount(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, Vector256<short> save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x8_t xvpcnt_w_s32 (int32x8_t a)
-        ///   LASX: XVPCNT_W Xd, Xj
+        /// int8x32_t xvfrstpi_b(int8x32_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.B Xd.32B, Xj.32B, ui4
         /// </summary>
-        public static Vector256<int> PopCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, const byte save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x8_t xvpcnt_w_u32 (uint32x8_t a)
-        ///   LASX: XVPCNT_W Xd, Xj
+        /// int16x16_t xvfrstpi_h(int16x16_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.H Xd.16H, Xj.16H, ui3
         /// </summary>
-        public static Vector256<uint> PopCount(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, const byte save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x4_t xvpcnt_d_s64 (int64x4_t a)
-        ///   LASX: XVPCNT_D Xd, Xj
+        /// int32x8_t vfclass_s(float32x8_t a)
+        ///   LASX: XVFCLASS.S Vd.8S, Vj.8S
         /// </summary>
-        public static Vector256<long> PopCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> FloatClass(Vector256<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x4_t xvpcnt_d_u64 (uint64x4_t a)
-        ///   LASX: XVPCNT_D Xd, Xj
+        /// int64x4_t vfclass_d(float64x4_t a)
+        ///   LASX: XVFCLASS.D Vd.4D, Vj.4D
         /// </summary>
-        public static Vector256<ulong> PopCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+        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
index 284fff38635e40..a470fe5462fd61 100644
--- 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
@@ -980,25 +980,25 @@ internal Lasx() { }
         /// 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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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)
@@ -1088,25 +1088,25 @@ internal Lasx() { }
         /// 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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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)
@@ -1172,25 +1172,25 @@ internal Lasx() { }
         /// 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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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)
@@ -1220,25 +1220,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> value,  [ConstantExpected(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
 
         /// <summary>
         /// uint8x32_t xvsle_bu(uint8x32_t a, uint8x32_t b)
@@ -1886,61 +1886,61 @@ internal Lasx() { }
         /// 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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)
@@ -2302,53 +2302,53 @@ internal Lasx() { }
         /// </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>
+        // /// 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)
@@ -3954,29 +3954,29 @@ internal Lasx() { }
         /// </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>
+        // /// 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>
+        // /// 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>
+        // /// 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>
+        // /// 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)
@@ -5699,7 +5699,5 @@ internal Lasx() { }
         ///   LASX: XVFCLASS.D Vd.4D, Vj.4D
         /// </summary>
         public static Vector256<long> FloatClass(Vector256<double> value) => FloatClass(value);
-
-        // TODO:----------------------------------
     }
 }
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
index 3017218463aff6..4e3609ac5f3194 100644
--- 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
@@ -4,7 +4,7 @@
 #pragma warning disable IDE0060 // unused parameters
 using System.Runtime.CompilerServices;
 
-namespace System.Runtime.Intrinsics.LoongArch64
+namespace System.Runtime.Intrinsics.LoongArch
 {
     /// <summary>
     /// This class provides access to the LA64 base hardware instructions via intrinsics
@@ -15,203 +15,288 @@ namespace System.Runtime.Intrinsics.LoongArch64
 #else
     internal
 #endif
-    abstract class LA64Base
+    abstract class LoongArchBase
     {
-        internal LA64Base() { }
+        internal LoongArchBase() { }
 
         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.D rd, rj
-        /// </summary>
-        public static int LeadingSignCount(long 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(); }
+        [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: 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: CRCC.W.B.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, byte checks) { throw new PlatformNotSupportedException(); }
 
-        /// <summary>
-        ///   LA64: MULH.D rd, rj, rk
-        /// </summary>
-        public static long MultiplyHigh(long left, long right) { 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: MULH.DU rd, rj, rk
-        /// </summary>
-        public static ulong MultiplyHigh(ulong left, ulong right) { 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: REVB.2W rd, rj
-        /// </summary>
-        public static int ReverseElementBits(int value) { 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>
-        ///   LA64: REVB.2W rd, rj
+        ///   LA32/LA64: MULH.W rd, rj, rk
         /// </summary>
-        public static uint ReverseElementBits(uint value) { throw new PlatformNotSupportedException(); }
+        public static long MultiplyHigh(int left, int right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: REVB.D rd, rj
+        ///   LA32/LA64: MULH.WU rd, rj, rk
         /// </summary>
-        public static long ReverseElementBits(long value) { throw new PlatformNotSupportedException(); }
+        public static ulong MultiplyHigh(uint left, uint right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: REVB.D rd, rj
-        /// </summary>
-        public static ulong ReverseElementBits(ulong value) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        ///   LA64: FSQRT.S fd, fj
+        ///   LA32/LA64: FSQRT.S fd, fj
         /// </summary>
         public static float SquareRoot(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: FSQRT.D fd, fj
+        ///   LA32/LA64: FSQRT.D fd, fj
         /// </summary>
         public static double SquareRoot(double value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: FRECIP.S fd, fj
+        ///   LA32/LA64: FRECIP.S fd, fj
         /// </summary>
         public static float Reciprocal(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: FRECIP.D fd, fj
+        ///   LA32/LA64: FRECIP.D fd, fj
         /// </summary>
         public static double Reciprocal(double value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: FRSQRT.S fd, fj
+        ///   LA32/LA64: FRSQRT.S fd, fj
         /// </summary>
         public static float ReciprocalSqrt(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: FRSQRT.D fd, fj
+        ///   LA32/LA64: FRSQRT.D fd, fj
         /// </summary>
         public static double ReciprocalSqrt(double value) { throw new PlatformNotSupportedException(); }
 
-#if false
-        // TODO-LA: adding  bstrins, bstrpick, bytepick
-        /// <summary>
-        ///   LA64: BYTEPICK.W rd, rj, sa2
-        /// </summary>
-        public static int SpliceAndCutBits(int left, int right, uint start) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        ///   LA64: BYTEPICK.W rd, rj, sa2
-        /// </summary>
-        public static uint SpliceAndCutBits(uint left, uint right, uint start) { throw new PlatformNotSupportedException(); }
-
         /// <summary>
-        ///   LA64: BYTEPICK.D rd, rj, sa3
+        ///   LA32/LA64: FLOGB.S fd, fj
         /// </summary>
-        public static long SpliceAndCutBits(long left, long right, uint start) { throw new PlatformNotSupportedException(); }
+        public static float FloatLogarithm2(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BYTEPICK.D rd, rj, sa3
+        ///   LA32/LA64: FLOGB.D fd, fj
         /// </summary>
-        public static ulong SpliceAndCutBits(ulong left, ulong right, uint start) { throw new PlatformNotSupportedException(); }
+        public static double FloatLogarithm2(double value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        ///   LA32/LA64: FSCALEB.S fd, fj, fk
         /// </summary>
-        public static int ReplaceBits(int left, int right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+        public static float FloatScaleBinary(float value, int index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRINS.W rd, rj, msbw, lsbw
+        ///   LA32/LA64: FSCALEB.D fd, fj, fk
         /// </summary>
-        public static uint ReplaceBits(uint left, uint right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+        public static double FloatScaleBinary(double value, long index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        ///   LA32/LA64: FCOPYSIGN.S fd, fj, fk
         /// </summary>
-        public static long ReplaceBits(long left, long right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+        public static float FloatCopySign(float value, float sign) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRINS.D rd, rj, msbd, lsbd
+        ///   LA32/LA64: FCOPYSIGN.D fd, fj, fk
         /// </summary>
-        public static ulong ReplaceBits(ulong left, ulong right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+        public static double FloatCopySign(double value, double sign) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        ///   LA32/LA64: FCLASS.S fd, fj
         /// </summary>
-        public static int CutBits(int left, int right, uint end, uint start) { throw new PlatformNotSupportedException(); }
+        public static float FloatClass(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   LA64: BSTRPICK.W rd, rj, msbw, lsbw
+        ///   LA32/LA64: FCLASS.S fd, fj
         /// </summary>
-        public static uint CutBits(uint left, uint right, uint end, uint start) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static long CutBits(long left, long right, uint end, uint start) { throw new PlatformNotSupportedException(); }
-
-        /// <summary>
-        ///   LA64: BSTRPICK.D rd, rj, msbd, lsbd
-        /// </summary>
-        public static ulong CutBits(ulong left, ulong right, uint end, uint start) { throw new PlatformNotSupportedException(); }
-#endif
+        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
index 03c8b31650f0b3..4e24b6f743623b 100644
--- 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
@@ -156,22 +156,22 @@ internal LoongArch64() { }
             /// <summary>
             ///   LA64: FRECIPE.S fd, fj
             /// </summary>
-            public static float ReciprocalExact(float value) => ReciprocalExact(value);
+            public static float ReciprocalEstimate(float value) => ReciprocalEstimate(value);
 
             /// <summary>
             ///   LA64: FRECIPE.D fd, fj
             /// </summary>
-            public static double ReciprocalExact(double value) => ReciprocalExact(value);
+            public static double ReciprocalEstimate(double value) => ReciprocalEstimate(value);
 
             /// <summary>
             ///   LA64: FRSQRTE.S fd, fj
             /// </summary>
-            public static float ReciprocalSqrtExact(float value) => ReciprocalSqrtExact(value);
+            public static float ReciprocalSqrtEstimate(float value) => ReciprocalSqrtEstimate(value);
 
             /// <summary>
             ///   LA64: FRSQRTE.D fd, fj
             /// </summary>
-            public static double ReciprocalSqrtExact(double value) => ReciprocalSqrtExact(value);
+            public static double ReciprocalSqrtEstimate(double value) => ReciprocalSqrtEstimate(value);
 
             /// <summary>
             ///   LA64: CRC.W.B.W rd, rj, rk
@@ -293,6 +293,5 @@ internal LoongArch64() { }
         ///   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
index 4989ca55312f8f..b8197507bf2af4 100644
--- 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
@@ -3,7 +3,7 @@
 
 using System.Runtime.CompilerServices;
 
-namespace System.Runtime.Intrinsics.LoongArch64
+namespace System.Runtime.Intrinsics.LoongArch
 {
     /// <summary>
     /// This class provides access to the LSX-128bits hardware instructions via intrinsics
@@ -14,2541 +14,5882 @@ namespace System.Runtime.Intrinsics.LoongArch64
 #else
     internal
 #endif
-    abstract class LA_LSX : LA64Base
+    abstract class Lsx : LoongArchBase
     {
-        internal LA_LSX() { }
+        internal Lsx() { }
 
         public static new bool IsSupported { [Intrinsic] get { return false; } }
 
         /// <summary>
-        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
+        /// int8x8_t vadd_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
         /// </summary>
-        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint8x8_t vadd_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
         /// </summary>
-        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vadd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
+        /// int16x4_t vadd_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
         /// </summary>
-        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint16x4_t vadd_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
         /// </summary>
-        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vadd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VADD.W Vd.4S, Vj.4S, Vk.4S
+        /// int32x2_t vadd_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
         /// </summary>
-        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// uint32x2_t vadd_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
         /// </summary>
-        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vadd_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
+        /// int64x1_t vadd_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> Add(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint64x1_t vadd_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> Add(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfadd_s_f32 (float32x4_t a, float32x4_t b)
+        /// float32x2_t vfadd_s(float32x2_t a, float32x2_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(); }
+        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfadd_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFADD.D Vd.2D, Vj.2D, Vk.2D
+        /// float64x1_t vfadd_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFADD.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<double> Add(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vsub_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// int8x16_t vadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint8x16_t vadd_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vsub_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// int16x8_t vadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint16x8_t vadd_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vsub_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// int32x4_t vadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// uint32x4_t vadd_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vsub_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// int64x2_t vadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint64x2_t vadd_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfsub_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// float32x4_t vfadd_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFADD.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfsub_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// float64x2_t vfadd_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vmul_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// int8x8_t vsadd_b(int8x8_t a, uint8x8_t b)
+        ///   LSX: VSADD.B Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// uint8x8_t vsadd_bu(uint8x8_t a, int8x8_t b)
+        ///   LSX: VSADD.BU Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmul_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// int16x4_t vsadd_h(int16x4_t a, uint16x4_t b)
+        ///   LSX: VSADD.H Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// uint16x4_t vsadd_hu(uint16x4_t a, int16x4_t b)
+        ///   LSX: VSADD.HU Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmul_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMULW Vd.4S, Vj.4S, Vk.4S
+        /// int32x2_t vsadd_w(int32x2_t a, uint32x2_t b)
+        ///   LSX: VSADD.W Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// uint32x2_t vsadd_wu(uint32x2_t a, int32x2_t b)
+        ///   LSX: VSADD.WU Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmul_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// int64x1_t vsadd_d(int64x1_t a, uint64x1_t b)
+        ///   LSX: VSADD.D Vd.D, Vj.D
         /// </summary>
-        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> AddSaturate(Vector64<long> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint64x1_t vsadd_du(uint64x1_t a, int64x1_t b)
+        ///   LSX: VSADD.DU Vd.D, Vj.D
         /// </summary>
-        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> AddSaturate(Vector64<ulong> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfmul_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
+        /// int8x16_t vsadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfmul_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vsadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vdiv_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vsadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vdiv_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VDIV.BU Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vsadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> Divide(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vdiv_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VDIV.H Vd.8H, Vj.8H, Vk.8H
+        /// uint8x16_t vsadd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> Divide(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vdiv_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VDIV.HU Vd.8H, Vj.8H, Vk.8H
+        /// uint16x8_t vsadd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vdiv_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// uint32x4_t vsadd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vdiv_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VDIV.WU Vd.4S, Vj.4S, Vk.4S
+        /// uint64x2_t vsadd_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vdiv_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> Divide(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vdiv_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VDIV.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> AddOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfdiv_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFDIV.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> Divide(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfdiv_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<double> Divide(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> AddOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfmadd_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S
+        /// 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<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfmadd_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
-        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vmadd_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
-        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmadd_h_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// 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> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// 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> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> AddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmadd_w_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMADD.W Vd.4S, Vj.4S, Vk.4S
+        /// 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> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// 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> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> AddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t TODO_s8 (int8x16_t a, uint8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B
+        /// 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<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, int8x16_t b)
-        ///   LSX: TODO Vd.16B, Vj.16B
+        /// 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<byte> AddSaturate(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t TODO_s16 (int16x8_t a, uint16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H
+        /// 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<short> AddSaturate(Vector128<short> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, int16x8_t b)
-        ///   LSX: TODO Vd.8H, Vj.8H
+        /// 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<ushort> AddSaturate(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t TODO_s32 (int32x4_t a, uint32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// 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<int> AddSaturate(Vector128<int> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddOddElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, int32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// 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<uint> AddSaturate(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> AddOddElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t TODO_s64 (int64x2_t a, uint64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// 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<long> AddSaturate(Vector128<long> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddOddElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, int64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// 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<ulong> AddSaturate(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> AddOddElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vsadd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vsadd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vsadd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSADD.W Vd.4S, Vj.4S, Vk.4S
+        /// 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<int> AddSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vsadd_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> AddSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsadd_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddEvenElementsWidening(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsadd_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddEvenElementsWidening(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsadd_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSADD.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddEvenElementsWidening(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsadd_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddEvenElementsWidening(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vadd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> HorizontalAdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AddOddElementsWidening(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> HorizontalAdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AddOddElementsWidening(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vadd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddElementsWidening(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> HorizontalAdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
-        /// <summary>
-        /// int32x4_t vadd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
-        /// </summary>
-        public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H.B Vd.8H, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<uint> HorizontalAdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vadd_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.HU.BU Vd.8H, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<long> HorizontalAdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t TODO_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W.H Vd.4W, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> HorizontalAdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
-
-        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
+        public static Vector128<long> AddHorizontalElements(Vector128<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: VHADDW.WU.HU Vd.4W, Vj.8H, Vk.8H
         /// </summary>
-        public static sbyte HorizontalSum(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.B Vd.16B, Vj.16B, Vk.16B
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: VHADDW.D.W Vd.2D, Vj.4W, Vk.4W
         /// </summary>
-        public static byte HorizontalSum(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: VHADDW.DU.WU Vd.2D, Vj.4W, Vk.4W
         /// </summary>
-        public static short HorizontalSum(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.H Vd.8H, Vj.8H, Vk.8H
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: VHADDW.Q.D Vd.Q, Vj.2D, Vk.2D
         /// </summary>
-        public static ushort HorizontalSum(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AddHorizontalElements(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: VHADDW.QU.DU Vd.Q, Vj.2D, Vk.2D
         /// </summary>
-        public static int HorizontalSum(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.W Vd.4S, Vj.4S, Vk.4S
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: sum_all_float_elements witin vector.
         /// </summary>
-        public static uint HorizontalSum(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> AddHorizontalElements(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
-        ///   LSX: Vector128.ToScalar
+        ///   LSX: sum_all_double_elements witin vector.
         /// </summary>
-        public static long HorizontalSum(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<double> AddHorizontalElements(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VHADDW.D Vd.2D, Vj.2D, Vk.2D
-        ///   LSX: Vector128.ToScalar
+        /// int8x8_t vsub_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
         /// </summary>
-        public static ulong HorizontalSum(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> Subtract(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: sum_all_float_elements witin value.
-        ///   LSX: Vector128.ToScalar
+        /// uint8x8_t vsub_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
         /// </summary>
-        public static float HorizontalSum(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> Subtract(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: sum_all_double_elements witin value.
-        ///   LSX: Vector128.ToScalar
+        /// int16x4_t vsub_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
         /// </summary>
-        public static double HorizontalSum(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> Subtract(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vmsub_b_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
-        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// uint16x4_t vsub_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
         /// </summary>
-        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> Subtract(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t TODO_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: TODO Vd.16B, Vj.16B, Vk.16B
+        /// int32x2_t vsub_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
         /// </summary>
-        public static Vector128<byte> MultiplySubtract(Vector128<byte> minuend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> Subtract(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmsub_h_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VMSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// uint32x2_t vsub_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
         /// </summary>
-        public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> Subtract(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t TODO_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: TODO Vd.8H, Vj.8H, Vk.8H
+        /// int64x1_t vsub_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> Subtract(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmsub_w_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// uint64x1_t vsub_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> Subtract(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t TODO_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// float32x2_t vfsub_s(float32x2_t a, float32x2_t b)
+        ///   LSX: VFSUB.S Vd.2S, Vj.2S, Vk.2S
         /// </summary>
-        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> Subtract(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmaddwev_h_b_s8 (int16x8_t a, int8x8_t b, int8x8_t c)
-        ///   LSX: VMADDWEV.H.B Vd.8H, Vj.8B, Vk.8B
+        /// float64x1_t vfsub_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFSUB.D Vd.D, Vj.D, Vk.D
         /// </summary>
-        public static Vector128<short> MultiplyWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<double> Subtract(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vmaddwev_h_bu_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c)
-        ///   LSX: VMADDWEV.H.BU Vd.8H, Vj.8B, Vk.8B
+        /// int8x16_t vsub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ushort> MultiplyWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmaddwev_w_h_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
-        ///   LSX: VMADDWEV.W.H Vd.4S, Vj.4H, Vk.4H
+        /// uint8x16_t vsub_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<int> MultiplyWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vmaddwev_w_hu_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
-        ///   LSX: VMADDWEV.W.HU Vd.4S, Vj.4H, Vk.4H
+        /// int16x8_t vsub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<uint> MultiplyWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmaddwev_d_w_s32 (int64x2_t a, int32x2_t b, int32x2_t c)
-        ///   LSX: VMADDWEV.D.W Vd.2D, Vj.2S, Vk.2S
+        /// uint16x8_t vsub_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> MultiplyWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vmaddwev_d_wu_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c)
-        ///   LSX: VMADDWEV.D.WU Vd.2D, Vj.2S, Vk.2S
+        /// int32x4_t vsub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ulong> MultiplyWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmaddwod_h_b_s8 (int16x8_t a, int8x16_t b, int8x16_t c)
-        ///   LSX: VMADDWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// uint32x4_t vsub_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<short> MultiplyWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vmaddwod_h_bu_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: VMADDWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// int64x2_t vsub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ushort> MultiplyWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmaddwod_w_h_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VMADDWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// uint64x2_t vsub_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<int> MultiplyWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vmaddwod_w_hu_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: VMADDWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// float32x4_t vfsub_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFSUB.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static Vector128<uint> MultiplyWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmaddwod_d_w_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// float64x2_t vfsub_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFSUB.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vmaddwod_d_wu_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// 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<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> SubtractOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vseq_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> SubtractOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vseq_b_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> SubtractOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vseq_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<short> CompareEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> SubtractOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vseq_h_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> SubtractOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vseq_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// 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<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> SubtractOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vseq_w_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSEQ.W Vd.4S, Vj.4S, Vk.4S
+        /// 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<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> SubtractOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vseq_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> SubtractOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vseq_d_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// int8x16_t vssub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSSUB.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vfcmp_ceq_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CEQ.S Vd.4S, Vj.4S, Vk.4S
+        /// uint8x16_t vssub_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSSUB.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vfcmp_ceq_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFCMP.CEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vssub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSSUB.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vslt_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// uint16x8_t vssub_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSSUB.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vslt_bu_s8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vssub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSSUB.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vslt_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// uint32x4_t vssub_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSSUB.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vslt_hu_s16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// int64x2_t vssub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSSUB.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslt_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// uint64x2_t vssub_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSSUB.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslt_wu_s32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// int8x16_t vmul_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vslt_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// uint8x16_t vmul_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vslt_du_s64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vmul_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// uint16x8_t vmul_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// int32x4_t vmul_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsle_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vmul(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsle_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vmul_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsle_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// uint64x2_t vmul(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsle_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// float32x4_t vfmul_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
         /// </summary>
-        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsle_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// float64x2_t vfmul_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// int8x16_t vmuh_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUH.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsle_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// uint8x16_t vmuh_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUH.BU Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsle_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vmuh_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUH.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyHight(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// uint16x8_t vmuh_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUH.HU Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// int32x4_t vmuh_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyHight(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsle_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vmuh_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUH.WU Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsle_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vmuh_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUH.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyHight(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsle_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// uint64x2_t vmuh_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUH.DU Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsle_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLE.W Vd.4S, Vj.4S, Vk.4S
+        /// 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, ulong data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsle_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLE.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Insert(Vector128<float> vector, float data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsle_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// 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<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Insert(Vector128<double> vector, double data, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsle_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// int8x16_t vreplgr2vr_b(int8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
         /// </summary>
-        public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> DuplicateToVector128(sbyte value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vfcmp_cle_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLE.S Vd.4S, Vj.4S, Vk.4S
+        /// uint8x16_t vreplgr2vr_b(uint8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
         /// </summary>
-        public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> DuplicateToVector128(byte value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vfcmp_cle_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// int16x8_t vreplgr2vr_h(int16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
         /// </summary>
-        public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> DuplicateToVector128(short value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vslt_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// uint16x8_t vreplgr2vr_h(uint16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
         /// </summary>
-        public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> DuplicateToVector128(ushort value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vslt_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vreplgr2vr_w(int32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
         /// </summary>
-        public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> DuplicateToVector128(int value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vslt_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// uint32x4_t vreplgr2vr_w(uint32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
         /// </summary>
-        public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> DuplicateToVector128(uint value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vslt_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// int64x2_t vreplgr2vr_d(int64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
         /// </summary>
-        public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> DuplicateToVector128(long value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslt_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSLT.W Vd.4S, Vj.4S, Vk.4S
+        /// uint64x2_t vreplgr2vr_d(uint64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
         /// </summary>
-        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> DuplicateToVector128(ulong value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslt_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSLT.WU Vd.4S, Vj.4S, Vk.4S
+        /// float32x4_t xvreplve0_w(float32_t value)
+        ///   LSX: XVREPLVE0.W Vd.4S, Vj.S[0]
         /// </summary>
-        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> DuplicateToVector128(float value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vslt_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// float64x2_t xvreplve0_d(float64_t value)
+        ///   LSX: XVREPLVE0.D Vd.2D, Vj.D[0]
         /// </summary>
-        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> DuplicateToVector128(double value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vslt_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// float32x4_t vffint_s_w(int32x4_t a)
+        ///   LSX: VFFINT.S.W Vd.4S, Vj.4W
         /// </summary>
-        public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> ConvertToSingle(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vfcmp_clt_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFCMP.CLT.S Vd.4S, Vj.4S, Vk.4S
+        /// float32x4_t vffint_s_wu(uint32x4_t a)
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4W
         /// </summary>
-        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> ConvertToSingle(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vfcmp_clt_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// float64x2_t vffint_d_l(int64x2_t a)
+        ///   LSX: VFFINT.D.L Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> ConvertToDouble(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vmax_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMAX.B Vd.16B, Vj.16B, Vk.16B
+        /// float64x2_t vffint_d_lu(uint64x2_t a)
+        ///   LSX: VFFINT.D.LU Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> ConvertToDouble(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vmax_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMAX.BU Vd.16B, Vj.16B, Vk.16B
+        /// int8_t vfsrtpi_b(uint8x16_t value)
+        ///   LSX: VFSRTPI.B Vd.16B, Vj.16B, 0
         /// </summary>
-        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static byte FirstNegativeInteger(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmax_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMAX.H Vd.8H, Vj.8H, Vk.8H
+        /// int16_t vfsrtpi_h(uint16x8_t value)
+        ///   LSX: VFSRTPI.H Vd.8H, Vj.8H, 0
         /// </summary>
-        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static ushort FirstNegativeInteger(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vmax_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMAX.HU Vd.8H, Vj.8H, Vk.8H
+        /// bool vsetnez_v(uint8x16_t value)
+        ///   LSX: VSETNEZ.V cd, Vj.16B
         /// </summary>
-        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmax_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMAX.W Vd.4S, Vj.4S, Vk.4S
+        /// bool vseteqz_v(uint8x16_t value)
+        ///   LSX: VSETEQZ.V cd, Vj.16B
         /// </summary>
-        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vmax_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMAX.WU Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetallnez_b(int8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
         /// </summary>
-        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmax_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMAX.D Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetallnez_b(uint8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
         /// </summary>
-        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vmax_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMAX.DU Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetallnez_h(int16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
         /// </summary>
-        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfmax_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFMAX.S Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetallnez_h(uint16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
         /// </summary>
-        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfmax_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFMAX.d Vd.2D, Vj.2D, Vk.2D
+        /// bool vsetallnez_w(int32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
         /// </summary>
-        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vmin_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMIN.B Vd.16B, Vj.16B, Vk.16B
+        /// bool vsetallnez_w(uint32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
         /// </summary>
-        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vmin_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMIN.BU Vd.16B, Vj.16B, Vk.16B
+        /// bool vsetallnez_w(int64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
         /// </summary>
-        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmin_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMIN.H Vd.8H, Vj.8H, Vk.8H
+        /// bool vsetallnez_w(uint64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
         /// </summary>
-        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static bool AllElementsNotZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vmin_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMIN.HU Vd.8H, Vj.8H, Vk.8H
+        /// bool vsetanyeqz_b(int8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
         /// </summary>
-        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmin_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMIN.W Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetanyeqz_b(uint8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
         /// </summary>
-        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vmin_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMIN.WU Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetanyeqz_h(int16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
         /// </summary>
-        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmin_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VMIN.D Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetanyeqz_h(uint16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
         /// </summary>
-        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vmin_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VMIN.DU Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetanyeqz_w(int32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
         /// </summary>
-        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfmin_s_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VFMIN.S Vd.4S, Vj.4S, Vk.4S
+        /// bool vsetanyeqz_w(uint32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
         /// </summary>
-        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfmin_d_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VFMIN.D Vd.2D, Vj.2D, Vk.2D
+        /// bool vsetanyeqz_w(int64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
         /// </summary>
-        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vbitsel_v_s8 (uint8x16_t a, int8x16_t b, int8x16_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// bool vsetanyeqz_w(uint64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
         /// </summary>
-        public static Vector128<sbyte> BitwiseSelect(Vector128<sbyte> select, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static bool HasElementsIsZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vbitsel_v_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// uint8x16_t vsrlni_b_h(uint16x8_t left, uint16x8_t right, shift)
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
         /// </summary>
-        public static Vector128<byte> BitwiseSelect(Vector128<byte> select, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vbitsel_v_s16 (uint16x8_t a, int16x8_t b, int16x8_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// int16x8_t vsrlni_h_w(int32x4_t left, int32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
         /// </summary>
-        public static Vector128<short> BitwiseSelect(Vector128<short> select, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vbitsel_v_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// uint16x8_t vsrlni_h_w(uint32x4_t left, uint32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
         /// </summary>
-        public static Vector128<ushort> BitwiseSelect(Vector128<ushort> select, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vbitsel_v_s32 (uint32x4_t a, int32x4_t b, int32x4_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vsrlni_w_d(int64x2_t left, int64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
         /// </summary>
-        public static Vector128<int> BitwiseSelect(Vector128<int> select, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vbitsel_v_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vsrlni_w_d(uint64x2_t left, uint64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
         /// </summary>
-        public static Vector128<uint> BitwiseSelect(Vector128<uint> select, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        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>
-        /// int64x2_t vbitsel_v_s64 (uint64x2_t a, int64x2_t b, int64x2_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// int8x8_t vsrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> BitwiseSelect(Vector128<long> select, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vbitsel_v_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// uint8x8_t vsrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ulong> BitwiseSelect(Vector128<ulong> select, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vbitsel_v_f32 (uint32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// int16x4_t vsrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<float> BitwiseSelect(Vector128<float> select, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vbitsel_v_f64 (uint64x2_t a, float64x2_t b, float64x2_t c)
-        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// uint16x4_t vsrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<double> BitwiseSelect(Vector128<double> select, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vabsd_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VABSD.B Vd.16B, Vj.16B, Vk.16B
+        /// int32x2_t vsrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> AbsoluteDifference(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vabsd_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VABSD.BU Vd.16B, Vj.16B, Vk.16B
+        /// uint32x2_t vsrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> AbsoluteDifference(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vabsd_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VABSD.H Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> AbsoluteDifference(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vabsd_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VABSD.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vabsd_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VABSD.W Vd.4S, Vj.4S, Vk.4S
+        /// 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<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vabsd_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VABSD.WU Vd.4S, Vj.4S, Vk.4S
+        /// 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<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vabsd_d_s64 (uint64x2_t a, int64x2_t b, int64x2_t c)
-        ///   LSX: VABSD.D Vd.16B, Vj.16B, Vk.16B
+        /// 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<ulong> AbsoluteDifference(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vabsd_du_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c)
-        ///   LSX: VABSD.DU Vd.16B, Vj.16B, Vk.16B
+        /// 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<ulong> AbsoluteDifference(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t TODO_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        /// int8x8_t vssrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<float> AbsoluteDifference(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t TODO_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        /// uint8x8_t vssrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vld_s8 (int8_t const * ptr)
-        ///   LSX: VLD Vd.16B, Rj, si12
+        /// int16x4_t vssrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vld_u8 (uint8_t const * ptr)
-        ///   LSX: VLD Vd.16B, Rj, si12
+        /// uint16x4_t vssrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static unsafe Vector128<byte> LoadVector128(byte* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vld_s16 (int16_t const * ptr)
-        ///   LSX: VLD Vd.8H, Rj, si12
+        /// int32x2_t vssrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static unsafe Vector128<short> LoadVector128(short* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vld_s16 (uint16_t const * ptr)
-        ///   LSX: VLD Vd.8H, Rj, si12
+        /// uint32x2_t vssrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static unsafe Vector128<ushort> LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vld_s32 (int32_t const * ptr)
-        ///   LSX: VLD Vd.4S, Rj, si12
+        /// 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 unsafe Vector128<int> LoadVector128(int* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vld_s32 (uint32_t const * ptr)
-        ///   LSX: VLD Vd.4S, Rj, si12
+        /// 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 unsafe Vector128<uint> LoadVector128(uint* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vld_s64 (int64_t const * ptr)
-        ///   LSX: VLD Vd.2D, Rj, si12
+        /// 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 unsafe Vector128<long> LoadVector128(long* address) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vld_u64 (uint64_t const * ptr)
-        ///   LSX: VLD Vd.2D, Rj, si12
+        /// uint8x8_t vssrln_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.BU.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static unsafe Vector128<ulong> LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vld_f32 (float32_t const * ptr)
-        ///   LSX: VLD Vd.4S, Rj, si12
+        /// uint16x4_t vssrln_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.HU.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static unsafe Vector128<float> LoadVector128(float* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vld_f64 (float64_t const * ptr)
-        ///   LSX: VLD Vd.2D, Rj, si12
+        /// uint32x2_t vssrln_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.WU.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static unsafe Vector128<double> LoadVector128(double* address) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrecip_s_f32 (float32x4_t a)
-        ///   LSX: VFRECIP.S Vd.4S Vj.4S
+        /// 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<float> Reciprocal(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrecip_d_f64 (float64x2_t a)
-        ///   LSX: VFRECIP.D Vd.2D Vj.2D
+        /// 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<double> Reciprocal(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrsqrt_s_f32 (float32x4_t a)
-        ///   LSX: VFRSQRT.S Vd.4S Vj.4S
+        /// 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<float> ReciprocalSqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrsqrt_d_f64 (float64x2_t a)
-        ///   LSX: VFRSQRT.D Vd.2D Vj.2D
+        /// int8x8_t vssran_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> ReciprocalSqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        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>
-        /// void vst_s8 (int8_t * ptr, int8x16_t val)
-        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// int32x2_t vssran_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_u8 (uint8_t * ptr, uint8x16_t val)
-        ///   LSX: VST { Vd.16B }, Rj, si12
+        /// 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 unsafe void Store(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_s16 (int16_t * ptr, int16x8_t val)
-        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// 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 unsafe void Store(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_u16 (uint16_t * ptr, uint16x8_t val)
-        ///   LSX: VST { Vd.8H }, Rj, si12
+        /// 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 unsafe void Store(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_s32 (int32_t * ptr, int32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// uint8x8_t vssran_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.BU.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static unsafe void Store(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_u32 (uint32_t * ptr, uint32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// uint16x4_t vssran_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRAN.HU.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static unsafe void Store(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_s64 (int64_t * ptr, int64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// uint32x2_t vssran_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.WU.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static unsafe void Store(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_u64 (uint64_t * ptr, uint64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// 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 unsafe void Store(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_f32 (float32_t * ptr, float32x4_t val)
-        ///   LSX: VST { Vd.4S }, Rj, si12
+        /// 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 unsafe void Store(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// void vst_f64 (float64_t * ptr, float64x2_t val)
-        ///   LSX: VST { Vd.2D }, Rj, si12
+        /// 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 unsafe void Store(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vneg_b_s8 (int8x16_t a)
-        ///   LSX: VNEG.B Vd.16B, Vj.16B
+        /// 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<sbyte> Negate(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vneg_h_s16 (int16x8_t a)
-        ///   LSX: VNEG.H Vd.8H, Vj.8H
+        /// 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<short> Negate(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vneg_w_s32 (int32x4_t a)
-        ///   LSX: VNEG.W Vd.4S, Vj.4S
+        /// 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<int> Negate(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vneg_d_s64 (int64x2_t a)
-        ///   LSX: VNEG.D Vd.2D, Vj.2D
+        /// int8x8_t vssrlrn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> Negate(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t TODO_f32 (float32x4_t a)
-        ///   LSX: TODO Vd.4S, Vj.4S
+        /// uint8x8_t vssrlrn_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<float> Negate(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t TODO_f64 (float64x2_t a)
-        ///   LSX: TODO Vd.2D, Vj.2D
+        /// int16x4_t vssrlrn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<double> Negate(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfmsub_s_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
-        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// uint16x4_t vssrlrn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfmsub_d_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
-        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// int32x2_t vssrlrn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vmulwod_h_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// uint32x2_t vssrlrn_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<short> MultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vmulwod_h_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// 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<ushort> MultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vmulwod_w_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VMULWOD.W.H Vd.4S, Vj.8H, Vk.8H
+        /// 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<int> MultiplyWideningUpper(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vmulwod_w_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VMULWOD.W.HU Vd.4S, Vj.8H, Vk.8H
+        /// 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> MultiplyWideningUpper(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vmulwod_d_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4S, Vk.4S
+        /// uint8x8_t vssrlrn_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.BU.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> MultiplyWideningUpper(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vmulwod_d_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4S, Vk.4S
+        /// uint16x4_t vssrlrn_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.HU.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ulong> MultiplyWideningUpper(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vssub_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VSSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// uint32x2_t vssrlrn_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.WU.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vssub_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VSSUB.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vssub_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VSSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// 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> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vssub_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VSSUB.HU Vd.8H, Vj.8H, Vk.8H
+        /// 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<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vssub_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VSSUB.W Vd.4S, Vj.4S, Vk.4S
+        /// int8x8_t vssrarn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.B.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vssub_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VSSUB.WU Vd.4S, Vj.4S, Vk.4S
+        /// int16x4_t vssrarn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.H.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vssub_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VSSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// int32x2_t vssrarn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.W.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vssub_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VSSUB.DU Vd.2D, Vj.2D, Vk.2D
+        /// 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<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vavg_b_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VAVG.B Vd.16B, Vj.16B, Vk.16B
+        /// 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<sbyte> Average(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vavg_bu_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VAVG.BU Vd.16B, Vj.16B, Vk.16B
+        /// 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<byte> Average(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vavg_h_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VAVG.H Vd.8H, Vj.8H, Vk.8H
+        /// uint8x8_t vssrarn_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.BU.H Vd.8B, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> Average(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vavg_hu_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VAVG.HU Vd.8H, Vj.8H, Vk.8H
+        /// uint16x4_t vssrarn_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.HU.W Vd.4H, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vavg_w_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VAVG.W Vd.4S, Vj.4S, Vk.4S
+        /// uint32x2_t vssrarn_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.WU.D Vd.2W, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vavg_wu_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VAVG.WU Vd.4S, Vj.4S, Vk.4S
+        /// int8x8_t vclo_b(int8x8_t a)
+        ///   LSX: VCLO.B Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vavg_d_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VAVG.D Vd.2D, Vj.2D, Vk.2D
+        /// int16x4_t vclo_h(int16x4_t a)
+        ///   LSX: VCLO.H Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<long> Average(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> LeadingSignCount(Vector64<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vavg_du_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VAVG.DU Vd.2D, Vj.2D, Vk.2D
+        /// int32x2_t vclo_w(int32x2_t a)
+        ///   LSX: VCLO.W Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<ulong> Average(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> LeadingSignCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vext2xv_h_b_s8 (int8x16_t a)
-        ///   LSX: VEXT2XV.H.B Vd.8H, Vj.16B
+        /// int64x1_t vclo_d(int64x1_t a)
+        ///   LSX: VCLO.D Vd.D, Vj.D
         /// </summary>
-        public static Vector128<short> SignExtendWideningLower(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> LeadingSignCount(Vector64<long> value) { throw new PlatformNotSupportedException(); }
 
-        ///// <summary>
-        ///// int32x4_t vext2xv_w_b_s8 (int8x16_t a)
-        /////   LSX: VEXT2XV.W.B Vd.4W, Vj.16B
-        ///// </summary>
-        //public static Vector128<int> SignExtendWideningLower(Vector128<sbyte> 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>
-        ///// int64x2_t vext2xv_d_b_s8 (int8x16_t a)
-        /////   LSX: VEXT2XV.D.B Vd.2D, Vj.16B
-        ///// </summary>
-        //public static Vector128<long> SignExtendWideningLower(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 vext2xv_w_h_s16 (int16x8_t a)
-        ///   LSX: VEXT2XV.W.H Vd.4W, Vj.8H
+        /// int32x4_t vclo_w(int32x4_t a)
+        ///   LSX: VCLO.W Vd.4W, Vj.4W
         /// </summary>
-        public static Vector128<int> SignExtendWideningLower(Vector128<short> value) { throw new PlatformNotSupportedException(); }
-
-        ///// <summary>
-        ///// int64x2_t vext2xv_d_h_s16 (int16x8_t a)
-        /////   LSX: VEXT2XV.D.H Vd.2D, Vj.8H
-        ///// </summary>
-        //public static Vector128<long> SignExtendWideningLower(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> LeadingSignCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vext2xv_d_w_s32 (int32x4_t a)
-        ///   LSX: VEXT2XV.D.W Vd.2D, Vj.4W
+        /// int64x2_t vclo_d(int64x2_t a)
+        ///   LSX: VCLO.D Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<long> SignExtendWideningLower(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> LeadingSignCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vext2xv_hu_bu_u8 (uint8x16_t a)
-        ///   LSX: VEXT2XV.HU.BU Vd.8H, Vj.16B
+        /// uint8x8_t vclz_b(uint8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<ushort> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-
-        ///// <summary>
-        ///// uint32x4_t vext2xv_wu_bu_u8 (uint8x16_t a)
-        /////   LSX: VEXT2XV.WU.BU Vd.4W, Vj.16B
-        ///// </summary>
-        //public static Vector128<uint> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
-
-        ///// <summary>
-        ///// uint64x2_t vext2xv_du_bu_u8 (uint8x16_t a)
-        /////   LSX: VEXT2XV.DU.BU Vd.2D, Vj.16B
-        ///// </summary>
-        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vext2xv_wu_hu_u16 (uint16x8_t a)
-        ///   LSX: VEXT2XV.WU.HU Vd.4W, Vj.8H
+        /// int8x8_t vclz_b(int8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
         /// </summary>
-        public static Vector128<uint> ZeroExtendWideningLower(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
 
-        ///// <summary>
-        ///// uint64x2_t vext2xv_du_hu_u16 (uint16x8_t a)
-        /////   LSX: VEXT2XV.DU.HU Vd.2D, Vj.8H
-        ///// </summary>
-        //public static Vector128<ulong> ZeroExtendWideningLower(Vector128<ushort> 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>
-        /// uint64x2_t vext2xv_du_wu_u32 (uint32x4_t a)
-        ///   LSX: VEXT2XV.DU.WU Vd.2D, Vj.4W
+        /// uint16x4_t vclz_h(uint16x4_t a)
+        ///   LSX: VCLZ.H Vd.4H, Vj.4H
         /// </summary>
-        public static Vector128<ulong> ZeroExtendWideningLower(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vexth_h_b_s8 (int8x16_t a)
-        ///   LSX: VEXTH.H.B Vd.8H, Vj.16B
+        /// int32x2_t vclz_w(int32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<short> SignExtendWideningUpper(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> LeadingZeroCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vexth_w_h_s16 (int16x8_t a)
-        ///   LSX: VEXTH.W.H Vd.4S, Vj.8H
+        /// uint32x2_t vclz_w(uint32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
         /// </summary>
-        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vexth_d_w_s32 (int32x4_t a)
-        ///   LSX: VEXTH.D.W Vd.2D, Vj.4S
+        /// int64x1_t vclz_d(int64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
         /// </summary>
-        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> LeadingZeroCount(Vector64<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vexth_HU_BU_u8 (uint8x16_t a)
-        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// uint64x1_t vclz_d(uint64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
         /// </summary>
-        public static Vector128<short> ZeroExtendWideningUpper(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> LeadingZeroCount(Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vexth_HU_BU_u8 (uint8x16_t a)
-        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// int8x16_t vclz_b(int8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
         /// </summary>
-        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
-        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// uint8x16_t vclz_b(uint8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
         /// </summary>
-        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vexth_WU_HU_u16 (uint16x8_t a)
-        ///   LSX: VEXTH.WU.HU Vd.4S, Vj.8H
+        /// int16x8_t vclz_h(int16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
         /// </summary>
-        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> LeadingZeroCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
-        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// uint16x8_t vclz_h(uint16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
         /// </summary>
-        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vexth_DU_WU_u32 (uint32x4_t a)
-        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4S
+        /// int32x4_t vclz_w(int32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
         /// </summary>
-        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> LeadingZeroCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vand_v_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vclz_w(uint32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
         /// </summary>
-        public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vand_v_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vclz_d(int64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> LeadingZeroCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vand_v_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// uint64x2_t vclz_d(uint64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<short> And(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vand_v_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// int8x16_t vpcnt_b(int8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
         /// </summary>
-        public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vand_v_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// uint8x16_t vpcnt_b(uint8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
         /// </summary>
-        public static Vector128<int> And(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> PopCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vand_v_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// int16x8_t vpcnt_h(int16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
         /// </summary>
-        public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> PopCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vand_v_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// uint16x8_t vpcnt_h(uint16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
         /// </summary>
-        public static Vector128<long> And(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> PopCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vand_v_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// int32x4_t vpcnt_w(int32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
         /// </summary>
-        public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> PopCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vand_v_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// uint32x4_t vpcnt_w(uint32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
         /// </summary>
-        public static Vector128<float> And(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> PopCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vand_v_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// int64x2_t vpcnt_d(int64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
         /// </summary>
-        public static Vector128<double> And(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> PopCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vandn_v_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// uint64x2_t vpcnt_d(uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
         /// </summary>
-        public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vandn_v_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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> AndNot(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector, Vector128<byte> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vandn_v_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<short> AndNot(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector, Vector128<sbyte> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vandn_v_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vandn_v_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<int> AndNot(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vandn_v_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<uint> AndNot(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vandn_v_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<long> AndNot(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vandn_v_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  int32x4_t vpermi_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorShuffle(Vector128<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vandn_v_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint32x4_t vpermi_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vandn_v_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<double> AndNot(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vor_v_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vor_v_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<byte> Or(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vor_v_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<short> Or(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vor_v_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int8x16_t vshuf4i_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorShuffleBy4Elements(Vector128<sbyte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vor_v_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint8x16_t vshuf4i_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorShuffleBy4Elements(Vector128<byte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vor_v_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int16x8_t vshuf4i_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
         /// </summary>
-        public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorShuffleBy4Elements(Vector128<short> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vor_v_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint16x8_t vshuf4i_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
         /// </summary>
-        public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorShuffleBy4Elements(Vector128<ushort> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vor_v_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int32x4_t vshuf4i_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorShuffleBy4Elements(Vector128<int> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vor_v_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint32x4_t vshuf4i_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorShuffleBy4Elements(Vector128<uint> vector, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vor_v_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<double> Or(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorShuffleBy4Elements(Vector128<long> vector0, Vector128<long> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vxor_v_s8 (int8x16_t a, int8x16_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  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<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorShuffleBy4Elements(Vector128<ulong> vector0, Vector128<ulong> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vxor_v_u8 (uint8x16_t a, uint8x16_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int8x16_t vilvl_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementsFusionLower(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vxor_v_s16 (int16x8_t a, int16x8_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint8x16_t vilvl_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementsFusionLower(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vxor_v_u16 (uint16x8_t a, uint16x8_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int16x8_t vilvl_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementsFusionLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vxor_v_s32 (int32x4_t a, int32x4_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint16x8_t vilvl_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementsFusionLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vxor_v_u32 (uint32x4_t a, uint32x4_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int32x4_t vilvl_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementsFusionLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vxor_v_s64 (int64x2_t a, int64x2_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint32x4_t vilvl_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementsFusionLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vxor_v_u64 (uint64x2_t a, uint64x2_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int64x2_t vilvl_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementsFusionLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vxor_v_f32 (float32x4_t a, float32x4_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  uint64x2_t vilvl_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementsFusionLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vxor_v_f64 (float64x2_t a, float64x2_t b)
-        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        ///  int8x16_t vilvh_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementsFusionHight(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vslli_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        ///  uint8x16_t vilvh_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementsFusionHight(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vslli_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSLLI.B Vd.16B, Vj.16B, #n
+        ///  int16x8_t vilvh_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementsFusionHight(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vslli_h_s16 (int16x8_t a, const int n)
-        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        ///  uint16x8_t vilvh_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementsFusionHight(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vslli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSLLI.H Vd.8H, Vj.8H, #n
+        ///  int32x4_t vilvh_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementsFusionHight(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslli_w_s32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        ///  uint32x4_t vilvh_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementsFusionHight(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vslli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSLLI.W Vd.4S, Vj.4S, #n
+        ///  int64x2_t vilvh_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementsFusionHight(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vslli_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        ///  uint64x2_t vilvh_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementsFusionHight(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vslli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSLLI.D Vd.2D, Vj.2D, #n
+        ///  int8x16_t vpackev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementsFusionEven(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        ///  uint8x16_t vpackev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementsFusionEven(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsrli_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLI.B Vd.16B, Vj.16B, #n
+        ///  int16x8_t vpackev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementsFusionEven(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        ///  uint16x8_t vpackev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementsFusionEven(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsrli_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLI.H Vd.8H, Vj.8H, #n
+        ///  int32x4_t vpackev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementsFusionEven(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        ///  uint32x4_t vpackev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementsFusionEven(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsrli_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLI.W Vd.4S, Vj.4S, #n
+        ///  int64x2_t vpackev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementsFusionEven(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        ///  uint64x2_t vpackev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementsFusionEven(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsrli_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLI.D Vd.2D, Vj.2D, #n
+        ///  int8x16_t vpackod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementsFusionOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        ///  uint8x16_t vpackod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementsFusionOdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vsrlri_b_u8 (uint8x16_t a, const int n)
-        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, #n
+        ///  int16x8_t vpackod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementsFusionOdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        ///  uint16x8_t vpackod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementsFusionOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vsrlri_h_u16 (uint16x8_t a, const int n)
-        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, #n
+        ///  int32x4_t vpackod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementsFusionOdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        ///  uint32x4_t vpackod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementsFusionOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vsrlri_w_u32 (uint32x4_t a, const int n)
-        ///   LSX: VSRLRI.W Vd.4S, Vj.4S, #n
+        ///  int64x2_t vpackod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementsFusionOdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        ///  uint64x2_t vpackod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementsFusionOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vsrlri_d_u64 (uint64x2_t a, const int n)
-        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, #n
+        ///  int8x16_t vpickev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorEvenElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vsrai_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSRAI.B Vd.16B, Vj.16B, #n
+        ///  uint8x16_t vpickev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorEvenElementsJoin(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vsrai_h_s16 (int16x8_t a, const int n)
-        ///   LSX: VSRAI.H Vd.8H, Vj.8H, #n
+        ///  int16x8_t vpickev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorEvenElementsJoin(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vsrai_w_s32 (int32x4_t a, const int n)
-        ///   LSX: VSRAI.W Vd.4S, Vj.4S, #n
+        ///  uint16x8_t vpickev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorEvenElementsJoin(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vsrai_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSRAI.D Vd.2D, Vj.2D, #n
+        ///  int32x4_t vpickev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorEvenElementsJoin(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vsrari_b_s8 (int8x16_t a, const int n)
-        ///   LSX: VSRARI.B Vd.16B, Vj.16B, #n
+        ///  uint32x4_t vpickev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorEvenElementsJoin(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vsrari_h_s16 (int16x8_t a, const int n)
-        ///   LSX: VSRARI.H Vd.8H, Vj.8H, #n
+        ///  int64x2_t vpickev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorEvenElementsJoin(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vsrari_w_s32 (int32x4_t a, const int n)
-        ///   LSX: VSRARI.W Vd.4S, Vj.4S, #n
+        ///  uint64x2_t vpickev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorEvenElementsJoin(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vsrari_d_s64 (int64x2_t a, const int n)
-        ///   LSX: VSRARI.D Vd.2D, Vj.2D, #n
+        ///  int8x16_t vpickod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorOddElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vadda_b_s8 (int8x16_t a)
-        ///   LSX: VADDA.B Vd.16B, Vd.16B, 0
+        ///  uint8x16_t vpickod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorOddElementsJoin(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vadda_h_s16 (int16x8_t a)
-        ///   LSX: VADDA.H Vd.8H, Vd.8H, 0
+        ///  int16x8_t vpickod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorOddElementsJoin(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vadda_w_s32 (int32x4_t a)
-        ///   LSX: VADDA.W Vd.4S, Vd.4S, 0
+        ///  uint16x8_t vpickod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorOddElementsJoin(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vdda_d_s64 (int64x2_t a)
-        ///   LSX: VADDA.D Vd.2D, Vd.2D, 0
+        ///  int32x4_t vpickod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ulong> Abs(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorOddElementsJoin(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vbitclri_w_f32 (float32x4_t a)
-        ///   LSX: VBITCLRI.W Vd.4S, Vj.4S, 31
+        ///  uint32x4_t vpickod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<float> Abs(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorOddElementsJoin(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vbitclri_d_f64 (float64x2_t a)
-        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, 63
+        ///  int64x2_t vpickod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<double> Abs(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorOddElementsJoin(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfsqrt_s_f32 (float32x4_t a)
-        ///   LSX: VFSQRT.S Vd.4S, Vj.4S
+        ///  uint64x2_t vpickod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<float> Sqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorOddElementsJoin(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfsqrt_d_f64 (float64x2_t a)
-        ///   LSX: VFSQRT.D Vd.2D, Vj.2D
+        ///  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<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementReplicate(Vector128<byte> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrintrm_s_f32 (float32x4_t a)
-        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        ///  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<float> Floor(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementReplicate(Vector128<sbyte> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrintrm_d_f64 (float64x2_t a)
-        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        ///  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<double> Floor(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementReplicate(Vector128<short> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrintrp_s_f32 (float32x4_t a)
-        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        ///  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<float> Ceiling(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementReplicate(Vector128<ushort> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrintrp_d_f64 (float64x2_t a)
-        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        ///  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<double> Ceiling(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementReplicate(Vector128<int> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrintrz_s_f32 (float32x4_t a)
-        ///   LSX: VFRINTRZ.S Vd.4S, Vj.4S
+        ///  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<float> RoundToZero(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementReplicate(Vector128<uint> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrintrz_d_f64 (float64x2_t a)
-        ///   LSX: VFRINTRZ.D Vd.2D, Vj.2D
+        ///  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<double> RoundToZero(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementReplicate(Vector128<long> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrintrm_s_f32 (float32x4_t a)
-        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        ///  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<float> RoundToNegativeInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementReplicate(Vector128<ulong> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrintrm_d_f64 (float64x2_t a)
-        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        ///  int8x16_t vextrins_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> UpdateOneVectorElement(Vector128<sbyte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vfrintrp_s_f32 (float32x4_t a)
-        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        ///  uint8x16_t vextrins_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
         /// </summary>
-        public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> UpdateOneVectorElement(Vector128<byte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vfrintrp_d_f64 (float64x2_t a)
-        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        ///  int16x8_t vextrins_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
         /// </summary>
-        public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> UpdateOneVectorElement(Vector128<short> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vinsgr2vr_b_s8 (int8_t a, int8x16_t v, const int imm)
-        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        ///  uint16x8_t vextrins_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
         /// </summary>
-        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> UpdateOneVectorElement(Vector128<ushort> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vinsgr2vr_b_u8 (uint8_t a, uint8x16_t v, const int imm)
-        ///   LSX: VINSGR2VR.B Vd.B[imm], Rj, imm
+        ///  int32x4_t vextrins_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> UpdateOneVectorElement(Vector128<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vinsgr2vr_h_s16 (int16_t a, int16x8_t v, const int imm)
-        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        ///  uint32x4_t vextrins_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
         /// </summary>
-        public static Vector128<short> Insert(Vector128<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> UpdateOneVectorElement(Vector128<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vinsgr2vr_h_u16 (uint16_t a, uint16x8_t v, const int imm)
-        ///   LSX: VINSGR2VR.H Vd.H[imm], Rj, imm
+        ///  int64x2_t vextrins_d(int64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
         /// </summary>
-        public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> UpdateOneVectorElement(Vector128<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vinsgr2vr_w_s32 (int32_t a, int32x4_t v, const int imm)
-        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        ///  uint64x2_t vextrins_d(uint64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
         /// </summary>
-        public static Vector128<int> Insert(Vector128<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> UpdateOneVectorElement(Vector128<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vinsgr2vr_w_u32 (uint32_t a, uint32x4_t v, const int imm)
-        ///   LSX: VINSGR2VR.W Vd.S[imm], Rj, imm
+        ///  int8x16_t vsigncov_b(int8x16_t sign, int8x16_t data)
+        ///   LSX: VSIGNCOV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementNegatedBySign(Vector128<sbyte> sign, Vector128<sbyte> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vinsgr2vr_d_s64 (int64_t a, int64x2_t v, const int imm)
-        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        ///  int16x8_t vsigncov_h(int16x8_t sign, int16x8_t data)
+        ///   LSX: VSIGNCOV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<long> Insert(Vector128<long> vector, byte index, long data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementNegatedBySign(Vector128<short> sign, Vector128<short> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vinsgr2vr_d_u64 (uint64_t a, uint64x2_t v, const int imm)
-        ///   LSX: VINSGR2VR.D Vd.D[imm], Rj, imm
+        ///  int32x4_t vsigncov_w(int32x4_t sign, int32x4_t data)
+        ///   LSX: VSIGNCOV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementNegatedBySign(Vector128<int> sign, Vector128<int> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t xvinsve0_w_f32 (float32_t a, float32x4_t v, const int imm)
-        ///   LSX: XVINSVE0.W Vd.S[imm], Vj.S[0], imm
+        ///  int64x2_t vsigncov_d(int64x2_t sign, int64x2_t data)
+        ///   LSX: VSIGNCOV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<float> Insert(Vector128<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementNegatedBySign(Vector128<long> sign, Vector128<long> data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t xvinsve0_d_f64 (float64_t a, float64x2_t v, const int imm)
-        ///   LSX: XVINSVE0.D Vd.D[imm], Vj.D[0], imm
+        /// int8x16_t vbitclri_b(int8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<double> Insert(Vector128<double> vector, byte index, double data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vreplgr2vr_b_s8 (int8_t value)
-        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// uint8x16_t vbitclri_b(uint8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static Vector128<sbyte> DuplicateToVector128(sbyte value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vreplgr2vr_b_u8 (uint8_t value)
-        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// int16x8_t vbitclri_h(int16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<byte> DuplicateToVector128(byte value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vreplgr2vr_h_s16 (int16_t value)
-        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// uint16x8_t vbitclri_h(uint16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static Vector128<short> DuplicateToVector128(short value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vreplgr2vr_h_u16 (uint16_t value)
-        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static Vector128<ushort> DuplicateToVector128(ushort value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vreplgr2vr_w_s32 (int32_t value)
-        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static Vector128<int> DuplicateToVector128(int value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vreplgr2vr_w_u32 (uint32_t value)
-        ///   LSX: VREPLGR2VR.W Vd.4S, Rj
+        /// int64x2_t vbitclri_d(int64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<uint> DuplicateToVector128(uint value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vreplgr2vr_d_s64 (int64_t value)
-        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// uint64x2_t vbitclri_d(uint64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static Vector128<long> DuplicateToVector128(long value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vreplgr2vr_d_u64 (uint64_t value)
-        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// int8x16_t vbitclr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<ulong> DuplicateToVector128(ulong value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t xvreplve0_w_f32 (float32_t value)
-        ///   LSX: XVREPLVE0.W Vd.4S, Vj.S[0]
+        /// uint8x16_t vbitclr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<float> DuplicateToVector128(float value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t xvreplve0_d_f64 (float64_t value)
-        ///   LSX: XVREPLVE0.D Vd.2D, Vj.D[0]
+        /// int16x8_t vbitclr_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<double> DuplicateToVector128(double value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vffint_s_w_f32_s32 (int32x4_t a)
-        ///   LSX: VFFINT.S.W Vd.4S, Vj.4S
+        /// uint16x8_t vbitclr_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<float> ConvertToSingle(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float32x4_t vffint_s_wu_f32_u32 (uint32x4_t a)
-        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4S
+        /// int32x4_t vbitclr_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<float> ConvertToSingle(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vffint_d_l_f64_s64 (int64x2_t a)
-        ///   LSX: VFFINT.D.L Vd.2D, Vj.2D
+        /// uint32x4_t vbitclr_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<double> ConvertToDouble(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// float64x2_t vffint_d_lu_f64_u64 (uint64x2_t a)
-        ///   LSX: VFFINT.D.LU Vd.2D, Vj.2D
+        /// int64x2_t vbitclr_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<double> ConvertToDouble(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8_t vfsrtpi_b_u8 (uint8x16_t value)
-        ///   LSX: VFSRTPI.B Vd.16B, Vj.16B, 0
+        /// uint64x2_t vbitclr_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static byte FirstNegativeInteger(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16_t vfsrtpi_h_u16 (uint16x8_t value)
-        ///   LSX: VFSRTPI.H Vd.8H, Vj.8H, 0
+        /// int8x16_t vbitseti_b(int8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static ushort FirstNegativeInteger(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetnez_v_u8 (uint8x16_t value)
-        ///   LSX: VSETNEZ.V cd, Vj.16B
+        /// uint8x16_t vbitseti_b(uint8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static bool HasElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vseteqz_v_u8 (uint8x16_t value)
-        ///   LSX: VSETEQZ.V cd, Vj.16B
+        /// int16x8_t vbitseti_h(int16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static bool AllElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_b_s8 (int8x16_t value)
-        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// uint16x8_t vbitseti_h(uint16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_b_u8 (uint8x16_t value)
-        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_h_s16 (int16x8_t value)
-        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_h_u16 (uint16x8_t value)
-        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// int64x2_t vbitseti_d(int64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_w_s32 (int32x4_t value)
-        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// uint64x2_t vbitseti_d(uint64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_w_u32 (uint32x4_t value)
-        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// int8x16_t vbitset_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_w_s64 (int64x2_t value)
-        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// uint8x16_t vbitset_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetallnez_w_u64 (uint64x2_t value)
-        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// int16x8_t vbitset_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static bool AllElementsNotZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_b_s8 (int8x16_t value)
-        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// uint16x8_t vbitset_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_b_u8 (uint8x16_t value)
-        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// int32x4_t vbitset_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_h_s16 (int16x8_t value)
-        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// uint32x4_t vbitset_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_h_u16 (uint16x8_t value)
-        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// int64x2_t vbitset_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_w_s32 (int32x4_t value)
-        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// uint64x2_t vbitset_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_w_u32 (uint32x4_t value)
-        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// int8x16_t vbitrevi_b(int8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// bool vsetanyeqz_w_s64 (int64x2_t value)
-        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// uint8x16_t vbitrevi_b(uint8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
-        /// bool vsetanyeqz_w_u64 (uint64x2_t value)
-        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// int16x8_t vbitrevi_h(int16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static bool HasElementsIsZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_b_h_16 (int16x8_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
-        ///   LSX: Vd Scalar to uint64.
+        /// uint16x8_t vbitrevi_h(uint16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_b_h_u16 (uint16x8_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
-        ///   LSX: Vd Scalar to uint64.
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_h_w_s32 (int32x4_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
-        ///   LSX: Vd Scalar to uint64.
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_h_w_u32 (uint32x4_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
-        ///   LSX: Vd Scalar to uint64.
+        /// int64x2_t vbitrevi_d(int64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_w_d_s64 (int64x2_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
-        ///   LSX: Vd Scalar to uint64.
+        /// uint64x2_t vbitrevi_d(uint64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<long> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// ulong vsrlni_w_d_u64 (uint64x2_t value, shift)
-        ///   NOTE: this is implemented by multi instructions.
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
-        ///   LSX: Vd Scalar to uint64.
+        /// int8x16_t vbitrev_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(Vector128<ulong> value, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16 vsrlni_b_h_u16 (uint16x8_t left, uint16x8_t right, shift)
-        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        /// uint8x16_t vbitrev_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8 vsrlni_h_w_s32 (int32x4_t left, int32x4_t right, shift)
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// int16x8_t vbitrev_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8 vsrlni_h_w_u32 (uint32x4_t left, uint32x4_t right, shift)
-        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// uint16x8_t vbitrev_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4 vsrlni_w_d_s64 (int64x2_t left, int64x2_t right, shift)
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// int32x4_t vbitrev_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4 vsrlni_w_d_u64 (uint64x2_t left, uint64x2_t right, shift)
-        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// uint32x4_t vbitrev_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int8x16_t vpcnt_b_s8 (int8x16_t a)
-        ///   LSX: VPCNT_B Vd, Vj
+        /// int64x2_t vbitrev_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint8x16_t vpcnt_b_u8 (uint8x16_t a)
-        ///   LSX: VPCNT_B Vd, Vj
+        /// uint64x2_t vbitrev_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
         /// </summary>
-        public static Vector128<byte> PopCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int16x8_t vpcnt_h_s16 (int16x8_t a)
-        ///   LSX: VPCNT_H Vd, Vj
+        /// int8x16_t vfrstp_b(int8x16_t value, int8x16_t save)
+        ///   LSX: VFRSTP.B Vd.16B, Vj.16B, Vk.16B
         /// </summary>
-        public static Vector128<short> PopCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, Vector128<sbyte> save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint16x8_t vpcnt_h_u16 (uint16x8_t a)
-        ///   LSX: VPCNT_H Vd, Vj
+        /// int16x8_t vfrstp_h(int16x8_t value, int16x8_t save)
+        ///   LSX: VFRSTP.H Vd.8H, Vj.8H, Vk.8H
         /// </summary>
-        public static Vector128<ushort> PopCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, Vector128<short> save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int32x4_t vpcnt_w_s32 (int32x4_t a)
-        ///   LSX: VPCNT_W Vd, Vj
+        /// int8x16_t vfrstpi_b(int8x16_t value, uint8_t save)
+        ///   LSX: VFRSTPI.B Vd.16B, Vj.16B, ui4
         /// </summary>
-        public static Vector128<int> PopCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, const byte save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint32x4_t vpcnt_w_u32 (uint32x4_t a)
-        ///   LSX: VPCNT_W Vd, Vj
+        /// int16x8_t vfrstpi_h(int16x8_t value, uint8_t save)
+        ///   LSX: VFRSTPI.H Vd.8H, Vj.8H, ui3
         /// </summary>
-        public static Vector128<uint> PopCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, const byte save) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// int64x2_t vpcnt_d_s64 (int64x2_t a)
-        ///   LSX: VPCNT_D Vd, Vj
+        /// int32x4_t vfclass_s(float32x4_t a)
+        ///   LSX: VFCLASS.S Vd.4S, Vj.4S
         /// </summary>
-        public static Vector128<long> PopCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> FloatClass(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        /// uint64x2_t vpcnt_d_u64 (uint64x2_t a)
-        ///   LSX: VPCNT_D Vd, Vj
+        /// int64x2_t vfclass_d(float64x2_t a)
+        ///   LSX: VFCLASS.D Vd.2D, Vj.2D
         /// </summary>
-        public static Vector128<ulong> PopCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+        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
index 5b597ced55a23c..971098955edd94 100644
--- 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
@@ -424,8 +424,6 @@ internal Lsx() { }
         /// </summary>
         public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right) => AddOddElementsWidening(left, right);
 
-        //// 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
@@ -1150,25 +1148,25 @@ internal Lsx() { }
         /// 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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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))] const sbyte si5) => CompareEqual(value, si5);
+        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)
@@ -1258,25 +1256,25 @@ internal Lsx() { }
         /// 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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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))] const sbyte si5) => CompareLessThan(value, si5);
+        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)
@@ -1342,25 +1340,25 @@ internal Lsx() { }
         /// 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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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))] const sbyte si5) => CompareLessThanOrEqual(value, si5);
+        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)
@@ -1390,25 +1388,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> value,  [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte ui5) => CompareLessThanOrEqual(value, ui5);
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value,  [ConstantExpected(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
 
         /// <summary>
         /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
@@ -1936,61 +1934,61 @@ internal Lsx() { }
         /// 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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)] const short si12) => LoadVector128(address, si12);
+        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)
@@ -2056,61 +2054,61 @@ internal Lsx() { }
         /// 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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)] const short si12) => LoadElementReplicateVector(address, si12);
+        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)
@@ -2400,77 +2398,77 @@ internal Lsx() { }
         /// </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> left, Vector128<sbyte> right) => MultiplyWideningEven(left, right);
-
-        /// <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) => MultiplyWideningEven(left, right);
-
-        /// <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) => MultiplyWideningEven(left, right);
-
-        /// <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) => MultiplyWideningEven(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)
@@ -3682,43 +3680,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
         /// int8x8_t vsrlrn_b_h(int16x8_t value, int16x8_t shift)
@@ -3856,25 +3854,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(31))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(63))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 0, 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(Min = 0, Max = (byte)(127))] const byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
 
         /// <summary>
         /// int8x8_t vsrarn_b_h(int16x8_t value, int16x8_t shift)
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 3a66c867842bb0..9a0473446759be 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -3959,47 +3959,92 @@ internal Arm64() { }
         }
     }
 }
-namespace System.Runtime.Intrinsics.LoongArch64
+namespace System.Runtime.Intrinsics.LoongArch
 {
     [System.CLSCompliantAttribute(false)]
-    public abstract partial class LA64Base
+    public abstract partial class LoongArchBase
     {
-        internal LA64Base() { }
+        internal LoongArchBase() { }
         public static bool IsSupported { get { throw null; } }
 
-        public static int LeadingSignCount(int value) { throw null; }
-        public static int LeadingSignCount(long 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 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 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 LA_LSX : System.Runtime.Intrinsics.LoongArch64.LA64Base
+    public abstract partial class Lsx : System.Runtime.Intrinsics.LoongArch.LoongArchBase
     {
-        internal LA_LSX() { }
+        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; }
@@ -4010,6 +4055,74 @@ internal LA_LSX() { }
         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; }
@@ -4020,6 +4133,22 @@ internal LA_LSX() { }
         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; }
@@ -4030,6 +4159,14 @@ internal LA_LSX() { }
         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; }
@@ -4040,48 +4177,56 @@ internal LA_LSX() { }
         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<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<double> addend, 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<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<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<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> 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<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> AddSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> AddSaturate(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector128<sbyte> 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<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> AddSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> AddSaturate(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<long> 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<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<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<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<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<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<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<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<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<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; }
@@ -4090,232 +4235,471 @@ internal LA_LSX() { }
         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<float> CompareEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> CompareEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> CompareLessThan(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> CompareLessThan(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<double> CompareLessThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> 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<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> 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<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<float> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<sbyte> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> 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<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<double> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<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<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<double> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> Max(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> Max(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<int> Min(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { 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<float> Min(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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<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<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<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<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<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<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<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<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<float> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> 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 System.Runtime.Intrinsics.Vector128<double> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadVector128(byte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadVector128(double* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadVector128(short* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadVector128(int* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> LoadVector128(long* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<sbyte> LoadVector128(sbyte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> LoadVector128(float* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ushort> LoadVector128(ushort* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> LoadVector128(uint* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> LoadVector128(ulong* address) { throw null; }
-        public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector128<byte> source) { }
-        public unsafe static void Store(double* address, System.Runtime.Intrinsics.Vector128<double> source) { }
-        public unsafe static void Store(short* address, System.Runtime.Intrinsics.Vector128<short> source) { }
-        public unsafe static void Store(int* address, System.Runtime.Intrinsics.Vector128<int> source) { }
-        public unsafe static void Store(long* address, System.Runtime.Intrinsics.Vector128<long> source) { }
-        public unsafe static void Store(sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> source) { }
-        public unsafe static void Store(float* address, System.Runtime.Intrinsics.Vector128<float> source) { }
-        public unsafe static void Store(ushort* address, System.Runtime.Intrinsics.Vector128<ushort> source) { }
-        public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector128<uint> source) { }
-        public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector128<ulong> source) { }
+        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.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> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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<int> SubtractSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> 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.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<sbyte> Average(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<short> Average(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> 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<short> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> 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<long> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<int> 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<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<double> And(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> And(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> And(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<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<int> AndNot(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> AndNot(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<double> AndNot(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<double> Or(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> Or(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> Or(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<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<double> Xor(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> 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<int> Xor(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<sbyte> Xor(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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<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<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<double> Sqrt(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Sqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.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; }
@@ -4326,54 +4710,30 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, sbyte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> vector, byte index, byte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> vector, byte index, short data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> vector, byte index, ushort data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> vector, byte index, int data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> vector, byte index, uint data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> vector, byte index, long data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> vector, byte index, ulong data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> vector, byte index, float data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> Insert(System.Runtime.Intrinsics.Vector128<double> vector, byte index, double data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateToVector128(sbyte value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateToVector128(byte value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> DuplicateToVector128(short value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateToVector128(ushort value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> DuplicateToVector128(int value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateToVector128(uint value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> DuplicateToVector128(long value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateToVector128(ulong value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> DuplicateToVector128(float value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> DuplicateToVector128(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 System.Runtime.Intrinsics.Vector128<sbyte> HorizontalAdd(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> HorizontalAdd(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> HorizontalAdd(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> HorizontalAdd(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> HorizontalAdd(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> HorizontalAdd(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> HorizontalAdd(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> HorizontalAdd(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
-        public static sbyte HorizontalSum(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
-        public static byte HorizontalSum(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
-        public static short HorizontalSum(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
-        public static ushort HorizontalSum(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
-        public static int HorizontalSum(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
-        public static uint HorizontalSum(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
-        public static long HorizontalSum(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
-        public static ulong HorizontalSum(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
-        public static float HorizontalSum(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
-        public static double HorizontalSum(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<uint> 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; }
@@ -4394,17 +4754,101 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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 ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<ushort> value, byte shift) { throw null; }
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<int> value, byte shift) { throw null; }
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<uint> value, byte shift) { throw null; }
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<long> value, byte shift) { throw null; }
-        public static ulong ShiftRightLogicalNarrowingLowerScalar(System.Runtime.Intrinsics.Vector128<ulong> value, byte shift) { 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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; }
@@ -4413,11 +4857,153 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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<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 LA_LASX : System.Runtime.Intrinsics.LoongArch64.LA_LSX
+    public abstract partial class Lasx : System.Runtime.Intrinsics.LoongArch.Lsx
     {
-        internal LA_LASX() { }
+        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; }
@@ -4430,6 +5016,56 @@ internal LA_LASX() { }
         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; }
@@ -4440,6 +5076,22 @@ internal LA_LASX() { }
         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; }
@@ -4450,6 +5102,14 @@ internal LA_LASX() { }
         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; }
@@ -4460,48 +5120,56 @@ internal LA_LASX() { }
         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<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<float> addend, System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<double> addend, 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<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<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<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> AddSaturate(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<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<byte> AddSaturate(System.Runtime.Intrinsics.Vector256<byte> 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<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> AddSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> AddSaturate(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector256<sbyte> 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<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> AddSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> AddSaturate(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> 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<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<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<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<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<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<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<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<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<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; }
@@ -4512,229 +5180,483 @@ internal LA_LASX() { }
         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<int> CompareLessThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> CompareLessThan(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<double> CompareLessThan(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> 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<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<float> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<float> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<double> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<double> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> Max(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> Max(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<int> Min(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { 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<float> Min(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<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<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<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<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<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<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<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<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<float> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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<double> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<byte> LoadVector256(byte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<double> LoadVector256(double* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<short> LoadVector256(short* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<int> LoadVector256(int* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<long> LoadVector256(long* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<sbyte> LoadVector256(sbyte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<float> LoadVector256(float* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ushort> LoadVector256(ushort* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<uint> LoadVector256(uint* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> LoadVector256(ulong* address) { throw null; }
-        public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector256<byte> source) { }
-        public unsafe static void Store(double* address, System.Runtime.Intrinsics.Vector256<double> source) { }
-        public unsafe static void Store(short* address, System.Runtime.Intrinsics.Vector256<short> source) { }
-        public unsafe static void Store(int* address, System.Runtime.Intrinsics.Vector256<int> source) { }
-        public unsafe static void Store(long* address, System.Runtime.Intrinsics.Vector256<long> source) { }
-        public unsafe static void Store(sbyte* address, System.Runtime.Intrinsics.Vector256<sbyte> source) { }
-        public unsafe static void Store(float* address, System.Runtime.Intrinsics.Vector256<float> source) { }
-        public unsafe static void Store(ushort* address, System.Runtime.Intrinsics.Vector256<ushort> source) { }
-        public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector256<uint> source) { }
-        public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector256<ulong> source) { }
+        //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<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> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<float> minuend, System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<double> minuend, System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningUpper(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<int> SubtractSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> 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<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<sbyte> Average(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<short> Average(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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<int> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector256<uint> value) { 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<double> And(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> And(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> And(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
-        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<sbyte> And(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<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<int> AndNot(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> AndNot(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<double> AndNot(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> AndNot(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> 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<double> Or(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> Or(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> Or(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<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<double> Xor(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<int> Xor(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> 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<sbyte> Xor(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<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<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, byte count) { 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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<double> Sqrt(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Sqrt(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
         public 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; }
@@ -4745,26 +5667,22 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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<sbyte> Insert(System.Runtime.Intrinsics.Vector256<sbyte> vector, byte index, sbyte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> Insert(System.Runtime.Intrinsics.Vector256<byte> vector, byte index, byte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> Insert(System.Runtime.Intrinsics.Vector256<short> vector, byte index, short data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> Insert(System.Runtime.Intrinsics.Vector256<ushort> vector, byte index, ushort data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> Insert(System.Runtime.Intrinsics.Vector256<int> vector, byte index, int data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> Insert(System.Runtime.Intrinsics.Vector256<uint> vector, byte index, uint data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> Insert(System.Runtime.Intrinsics.Vector256<long> vector, byte index, long data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> Insert(System.Runtime.Intrinsics.Vector256<ulong> vector, byte index, ulong data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Insert(System.Runtime.Intrinsics.Vector256<float> vector, byte index, float data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Insert(System.Runtime.Intrinsics.Vector256<double> vector, byte index, double data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> DuplicateToVector256(sbyte value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> DuplicateToVector256(byte value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> DuplicateToVector256(short value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> DuplicateToVector256(ushort value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> DuplicateToVector256(int value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> DuplicateToVector256(uint value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> DuplicateToVector256(long value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> DuplicateToVector256(ulong value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> DuplicateToVector256(float value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> DuplicateToVector256(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; }
@@ -4787,6 +5705,98 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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; }
@@ -4795,6 +5805,155 @@ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector
         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<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

From 952a76b32739f5b61a1a16a4b46c0dca6469cedb Mon Sep 17 00:00:00 2001
From: qiaopengcheng <qiaopengcheng@loongson.cn>
Date: Thu, 7 Dec 2023 20:37:25 +0800
Subject: [PATCH 11/11] add VectorSaturate and VectorSaturateUnsigned. Also
 amend some code-formate.

---
 .../LoongArch/Lasx.PlatformNotSupported.cs    | 178 +++++++++------
 .../Runtime/Intrinsics/LoongArch/Lasx.cs      | 178 +++++++++------
 .../LoongArch/Lsx.PlatformNotSupported.cs     | 178 +++++++++------
 .../Runtime/Intrinsics/LoongArch/Lsx.cs       | 178 +++++++++------
 .../ref/System.Runtime.Intrinsics.cs          | 208 ++++++++++--------
 5 files changed, 564 insertions(+), 356 deletions(-)

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
index c8889fd206a529..c0a10d7aa1ae1f 100644
--- 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
@@ -984,25 +984,25 @@ internal Lasx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1092,25 +1092,25 @@ internal Lasx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1176,25 +1176,25 @@ internal Lasx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1224,25 +1224,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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)
@@ -3548,43 +3548,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -3626,25 +3626,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4262,43 +4262,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4340,25 +4340,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4382,25 +4382,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4424,25 +4424,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4466,43 +4466,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4544,25 +4544,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4586,25 +4586,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4628,25 +4628,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -5668,6 +5668,54 @@ internal Lasx() { }
         /// </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
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
index a470fe5462fd61..1fa8728238d49a 100644
--- 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
@@ -980,25 +980,25 @@ internal Lasx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1088,25 +1088,25 @@ internal Lasx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1172,25 +1172,25 @@ internal Lasx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1220,25 +1220,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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)
@@ -3544,43 +3544,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+        //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)
@@ -3622,25 +3622,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+        //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)
@@ -4282,43 +4282,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+        //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)
@@ -4360,25 +4360,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        //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)
@@ -4402,25 +4402,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+        //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)
@@ -4444,25 +4444,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        //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)
@@ -4486,43 +4486,43 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        //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)
@@ -4564,25 +4564,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        //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)
@@ -4606,25 +4606,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+        //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)
@@ -4648,25 +4648,25 @@ internal Lasx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+        //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)
@@ -5688,6 +5688,54 @@ internal Lasx() { }
         /// </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
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
index b8197507bf2af4..d970df04c3c7cf 100644
--- 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
@@ -1154,25 +1154,25 @@ internal Lsx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1262,25 +1262,25 @@ internal Lsx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1346,25 +1346,25 @@ internal Lsx() { }
         /// 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(); }
+        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(); }
+        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(); }
+        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(); }
+        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)
@@ -1394,25 +1394,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+        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)
@@ -3686,43 +3686,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -3860,25 +3860,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4436,43 +4436,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4514,25 +4514,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4556,25 +4556,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4598,25 +4598,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4640,43 +4640,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4718,25 +4718,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4760,25 +4760,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -4802,25 +4802,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        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(Min = 0, Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        //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)
@@ -5880,6 +5880,54 @@ internal Lsx() { }
         /// </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
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
index 971098955edd94..5d6595af3a391d 100644
--- 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
@@ -1148,25 +1148,25 @@ internal Lsx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1256,25 +1256,25 @@ internal Lsx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1340,25 +1340,25 @@ internal Lsx() { }
         /// 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);
+        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);
+        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);
+        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);
+        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)
@@ -1388,25 +1388,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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(Min = 0, Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+        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)
@@ -3680,43 +3680,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+        //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)
@@ -3854,25 +3854,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+        //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)
@@ -4430,43 +4430,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+        //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)
@@ -4508,25 +4508,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+        //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)
@@ -4550,25 +4550,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+        //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)
@@ -4592,25 +4592,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+        //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)
@@ -4634,43 +4634,43 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+        //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)
@@ -4712,25 +4712,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        //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)
@@ -4754,25 +4754,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+        //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)
@@ -4796,25 +4796,25 @@ internal Lsx() { }
         /// 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(Min = 0, Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        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(Min = 0, Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+        //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)
@@ -5874,6 +5874,54 @@ internal Lsx() { }
         /// </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
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 9a0473446759be..c90a5828490008 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -4263,10 +4263,10 @@ internal Lsx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(31))] byte ui5) { 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; }
@@ -4643,12 +4643,12 @@ internal Lsx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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; }
@@ -4671,9 +4671,9 @@ internal Lsx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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; }
@@ -4765,63 +4765,63 @@ internal Lsx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(63))] byte 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; }
@@ -4997,6 +4997,14 @@ internal Lsx() { }
         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; }
     }
@@ -5206,10 +5214,10 @@ internal Lasx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(31))] byte ui5) { 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; }
@@ -5598,23 +5606,23 @@ internal Lasx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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; }
@@ -5717,71 +5725,71 @@ internal Lasx() { }
         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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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(Min = 0, 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(Min = 0, 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(Min = 0, 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(Min = 0, Max = (byte)(127))] byte 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; }
@@ -5952,6 +5960,14 @@ internal Lasx() { }
         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; }
     }