Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[API Proposal]: LoongArch64: add Intrinsics' API for LoongArch64 #94445

Open
shushanhf opened this issue Nov 7, 2023 · 8 comments
Open

[API Proposal]: LoongArch64: add Intrinsics' API for LoongArch64 #94445

shushanhf opened this issue Nov 7, 2023 · 8 comments
Labels
api-suggestion Early API idea and discussion, it is NOT ready for implementation area-System.Runtime.Intrinsics needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration
Milestone
Future

Comments

@shushanhf
Copy link
Contributor

shushanhf commented Nov 7, 2023 •
edited
Loading

Background and motivation

Now the GCC had merged the LoongArch's SIMD.
https://github.com/gcc-mirror/gcc/blob/master/gcc/config/loongarch/lsxintrin.h
https://github.com/gcc-mirror/gcc/blob/master/gcc/config/loongarch/lasxintrin.h

Also the LLVM is merging the LoongArch's SIMD.

I think it's time to add the LoongArch's SIMD for CoreCLR.
There is a draft PR #94400 for the LoongArch's SIMD for CoreCLR.

API Proposal

namespace System.Runtime.Intrinsics.LoongArch
{
    /// <summary>
    /// This class provides access to the LA64 base hardware instructions via intrinsics
    /// </summary>
    [Intrinsic]
    [CLSCompliant(false)]
    public abstract class LABase
    {
        internal LABase() { }

        public static bool IsSupported { get => IsSupported; }

        [Intrinsic]
        public abstract class LoongArch64
        {
              // Some APIs for LoongArch64.
        }

        // Some APIs for LoongArch32/64 shared.
    }
}

I will upload these APIs later classified by different types.

API Usage

            if (LABase.IsSupported)
            {
                return LABase.TrailingZeroCount(value);
            }

Alternative Designs

No response

Risks

No response
@shushanhf shushanhf added the api-suggestion Early API idea and discussion, it is NOT ready for implementation label Nov 7, 2023
@dotnet-issue-labeler dotnet-issue-labeler bot added the needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners label Nov 7, 2023
@ghost ghost added the untriaged New issue has not been triaged by the area owner label Nov 7, 2023
@shushanhf shushanhf mentioned this issue Nov 7, 2023
Open
@shushanhf
Copy link
Contributor Author

The Plans for discussion:
(1) Part of the LoongArch Base hardware instrinsics, that is, the common APIs which are quite simlar with other CPUs considered first.
(2) The SIMD-128bits which is the Lsx class for LoongArch, the common APIs which are quite simlar with other CPUs considered first.
(3) The SIMD-256bits which is the Lasx class for LoongArch, the common APIs which are quite simlar with other CPUs considered first.

Then, some quite different hardware instructions with other CPUs.

@huoyaoyuan huoyaoyuan added area-System.Runtime.Intrinsics and removed needs-area-label An area label is needed to ensure this gets routed to the appropriate area owners labels Nov 7, 2023
@ghost
Copy link

ghost commented Nov 7, 2023

Tagging subscribers to this area: @dotnet/area-system-runtime-intrinsics
See info in area-owners.md if you want to be subscribed.

Issue Details

Background and motivation

Now the GCC had merged the LoongArch's SIMD. https://github.com/shushanhf/gcc/blob/master/gcc/config/loongarch/lasxintrin.h

Also the LLVM is merging the LoongArch's SIMD.

I think it's time to add the LoongArch's SIMD for CoreCLR.
There is a draft PR #94400 for the LoongArch's SIMD for CoreCLR.

API Proposal

namespace System.Runtime.Intrinsics.LoongArch
{
    /// <summary>
    /// This class provides access to the LA64 base hardware instructions via intrinsics
    /// </summary>
    [Intrinsic]
    [CLSCompliant(false)]
    public abstract class LABase
    {
        internal LABase() { }

        public static bool IsSupported { get => IsSupported; }

        [Intrinsic]
        public abstract class LoongArch64
        {
              // Some APIs for LoongArch64.
        }

        // Some APIs for LoongArch32/64 shared.
    }
}

I will upload these APIs later classified by different types.

API Usage

            if (LABase.IsSupported)
            {
                return LABase.TrailingZeroCount(value);
            }

Alternative Designs

No response

Risks

No response

Author: shushanhf
Assignees: -
Labels:

api-suggestion, area-System.Runtime.Intrinsics, untriaged
Milestone: -

@shushanhf
Copy link
Contributor Author

The Plans for discussion: (1) Part of the LoongArch Base hardware instrinsics, that is, the common APIs which are quite simlar with other CPUs considered first.

liking
https://github.com/dotnet/runtime/pull/94400/files#diff-cad74f6de47477ad12e4b0431d9938feda6e913f0147060c3b5bdde7f73d2499
Is this name OK for LoongArch's base HW-instruction?

    public abstract class LoongArchBase

https://github.com/shushanhf/runtime/blob/5c601e1154c1a44f7f0b8f8ab4d5eb0e380d066e/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs#L13

(2) The SIMD-128bits which is the Lsx class for LoongArch, the common APIs which are quite simlar with other CPUs considered first. (3) The SIMD-256bits which is the Lasx class for LoongArch, the common APIs which are quite simlar with other CPUs considered first.

Then, some quite different hardware instructions with other CPUs.

@tannergooding
Copy link
Member

Where is the spec for the LA64 SIMD ISA?

Based on https://loongson.github.io/LoongArch-Documentation/README-EN.html, it looks like it should be Volume 2, but there doesn't appear to be any version published for it yet and the backing GitHub repo looks to be archived now and I do not see a replacement.

@shushanhf
Copy link
Contributor Author

shushanhf commented Feb 18, 2024 •
edited
Loading

Click to expand 'public abstract class LoongArchBase' 
namespace System.Runtime.Intrinsics.LoongArch;

    public abstract class LoongArchBase
    {
        internal LoongArchBase() { } 

        public static bool IsSupported { get => IsSupported; }

        [Intrinsic]
        public abstract class LoongArch64
        {
            internal LoongArch64() { } 

            public static bool IsSupported { get => IsSupported; }

            /// <summary>
            ///   LA64: CLO.W rd, rj
            /// </summary>
            public static int LeadingSignCount(int value) => LeadingSignCount(value);

            /// <summary>
            ///   LA64: CLO.W rd, rj
            /// </summary>
            public static int LeadingSignCount(uint value) => LeadingSignCount(value);

            /// <summary>
            ///   LA64: CLO.D rd, rj
            /// </summary>
            public static int LeadingSignCount(long value) => LeadingSignCount(value);

            /// <summary>
            ///   LA64: CLO.D rd, rj
            /// </summary>
            public static int LeadingSignCount(ulong value) => LeadingSignCount(value);

            /// <summary>
            ///   LA64: CLZ.W rd, rj
            /// </summary>
            public static int LeadingZeroCount(int value) => LeadingZeroCount(value);

            /// <summary>
            ///   LA64: CLZ.W rd, rj
            /// </summary>
            public static int LeadingZeroCount(uint value) => LeadingZeroCount(value);

            /// <summary>
            ///   LA64: CLZ.D rd, rj
            /// </summary>
            public static int LeadingZeroCount(long value) => LeadingZeroCount(value);

            /// <summary>
            ///   LA64: CLZ.D rd, rj
            /// </summary>
            public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value);

            /// <summary>
            ///   LA64: CTO.W rd, rj
            /// </summary>
            public static int TrailingOneCount(int value) => TrailingOneCount(value);

            /// <summary>
            ///   LA64: CTO.W rd, rj
            /// </summary>
            public static int TrailingOneCount(uint value) => TrailingOneCount(value);

            /// <summary>
            ///   LA64: CTO.D rd, rj
            /// </summary>
            public static int TrailingOneCount(long value) => TrailingOneCount(value);

            /// <summary>
            ///   LA64: CTO.D rd, rj
            /// </summary>
            public static int TrailingOneCount(ulong value) => TrailingOneCount(value);

            /// <summary>
            ///   LA64: CTZ.W rd, rj
            /// </summary>
            public static int TrailingZeroCount(int value) => TrailingZeroCount(value);

            /// <summary>
            ///   LA64: CTZ.W rd, rj
            /// </summary>
            public static int TrailingZeroCount(uint value) => TrailingZeroCount(value);

            /// <summary>
            ///   LA64: CTZ.D rd, rj
            /// </summary>
            public static int TrailingZeroCount(long value) => TrailingZeroCount(value);

            /// <summary>
            ///   LA64: CTZ.D rd, rj
            /// </summary>
            public static int TrailingZeroCount(ulong value) => TrailingZeroCount(value);

            /// <summary>
            ///   LA64: MULH.D rd, rj, rk
            /// </summary>
            public static long MultiplyHigh(long left, long right) => MultiplyHigh(left, right);

            /// <summary>
            ///   LA64: MULH.DU rd, rj, rk
            /// </summary>
            public static ulong MultiplyHigh(ulong left, ulong right) => MultiplyHigh(left, right);

            /// <summary>
            ///   LA64: BITREV.D rd, rj
            /// </summary>
            public static long ReverseElementBits(long value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: BITREV.D rd, rj
            /// </summary>
            public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: BITREV.W rd, rj
            /// </summary>
            public static long ReverseElementBits(int value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: BITREV.W rd, rj
            /// </summary>
            public static ulong ReverseElementBits(uint value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: REVB.2W rd, rj
            /// </summary>
            public static int ReverseElementBits(int value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: REVB.2W rd, rj
            /// </summary>
            public static uint ReverseElementBits(uint value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: REVB.D rd, rj
            /// </summary>
            public static long ReverseElementBits(long value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: REVB.D rd, rj
            /// </summary>
            public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);

            /// <summary>
            ///   LA64: FRECIPE.S fd, fj
            /// </summary>
            public static float ReciprocalEstimate(float value) => ReciprocalEstimate(value);

            /// <summary>
            ///   LA64: FRECIPE.D fd, fj
            /// </summary>
            public static double ReciprocalEstimate(double value) => ReciprocalEstimate(value);
            /// <summary>
            ///   LA64: FRSQRTE.S fd, fj
            /// </summary>
            public static float ReciprocalSqrtEstimate(float value) => ReciprocalSqrtEstimate(value);

            /// <summary>
            ///   LA64: FRSQRTE.D fd, fj
            /// </summary>
            public static double ReciprocalSqrtEstimate(double value) => ReciprocalSqrtEstimate(value);

            /// <summary>
            ///   LA64: CRC.W.B.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckIEEE8023(int crc, byte checks) => CyclicRedundancyCheckIEEE8023(crc, checks);

            /// <summary>
            ///   LA64: CRC.W.H.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckIEEE8023(int crc, ushort checks) => CyclicRedundancyCheckIEEE8023(crc, checks);

            /// <summary>
            ///   LA64: CRC.W.W.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckIEEE8023(int crc, uint checks) => CyclicRedundancyCheckIEEE8023(crc, checks);

            /// <summary>
            ///   LA64: CRC.W.D.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckIEEE8023(int crc, ulong checks) => CyclicRedundancyCheckIEEE8023(crc, checks);

            /// <summary>
            ///   LA64: CRCC.W.B.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckCastagnoli(int crc, byte checks) => CyclicRedundancyCheckCastagnoli(crc, checks);

            /// <summary>
            ///   LA64: CRCC.W.H.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckCastagnoli(int crc, ushort checks) => CyclicRedundancyCheckCastagnoli(crc, checks);

            /// <summary>
            ///   LA64: CRCC.W.W.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckCastagnoli(int crc, uint checks) => CyclicRedundancyCheckCastagnoli(crc, checks);

            /// <summary>
            ///   LA64: CRCC.W.D.W rd, rj, rk
            /// </summary>
            public static long CyclicRedundancyCheckCastagnoli(int crc, ulong checks) => CyclicRedundancyCheckCastagnoli(crc, checks);
        }

        /// <summary>
        ///   LA32/LA64: MULH.W rd, rj, rk
        /// </summary>
        public static long MultiplyHigh(int left, int right) => MultiplyHigh(left, right);

        /// <summary>
        ///   LA32/LA64: MULH.WU rd, rj, rk
        /// </summary>
        public static ulong MultiplyHigh(uint left, uint right) => MultiplyHigh(left, right);

        /// <summary>
        ///   LA32/LA64: FSQRT.S fd, fj
        /// </summary>
        public static float SquareRoot(float value) => SquareRoot(value);

        /// <summary>
        ///   LA32/LA64: FSQRT.D fd, fj
        /// </summary>
        public static double SquareRoot(double value) => SquareRoot(value);

        /// <summary>
        ///   LA32/LA64: FRECIP.S fd, fj
        /// </summary>
        public static float Reciprocal(float value) => Reciprocal(value);

        /// <summary>
        ///   LA32/LA64: FRECIP.D fd, fj
        /// </summary>
        public static double Reciprocal(double value) => Reciprocal(value);

        /// <summary>
        ///   LA32/LA64: FRSQRT.S fd, fj
        /// </summary>
        public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);

        /// <summary>
        ///   LA32/LA64: FRSQRT.D fd, fj
        /// </summary>
        public static double ReciprocalSqrt(double value) => ReciprocalSqrt(value);

        /// <summary>
        ///   LA32/LA64: FLOGB.S fd, fj
        /// </summary>
        public static float FloatLogarithm2(float value) => FloatLogarithm2(value);

        /// <summary>
        ///   LA32/LA64: FLOGB.D fd, fj
        /// </summary>
        public static double FloatLogarithm2(double value) => FloatLogarithm2(value);

        /// <summary>
        ///   LA32/LA64: FSCALEB.S fd, fj, fk
        /// </summary>
        public static float FloatScaleBinary(float value, int index) => FloatScaleBinary(value, index);

        /// <summary>
        ///   LA32/LA64: FSCALEB.D fd, fj, fk
        /// </summary>
        public static double FloatScaleBinary(double value, long index) => FloatScaleBinary(value, index);

        /// <summary>
        ///   LA32/LA64: FCOPYSIGN.S fd, fj, fk
        /// </summary>
        public static float FloatCopySign(float value, float sign) => FloatCopySign(value, sign);

        /// <summary>
        ///   LA32/LA64: FCOPYSIGN.D fd, fj, fk
        /// </summary>
        public static double FloatCopySign(double value, double sign) => FloatCopySign(value, sign);

        /// <summary>
        ///   LA32/LA64: FCLASS.S fd, fj
        /// </summary>
        public static float FloatClass(float value) => FloatClass(value);

        /// <summary>
        ///   LA32/LA64: FCLASS.S fd, fj
        /// </summary>
        public static double FloatClass(double value) => FloatClass(value);
    }

@shushanhf
Copy link
Contributor Author

shushanhf commented Feb 18, 2024 •
edited
Loading

Click to expand 'public abstract class Lsx : LoongArchBase' 
namespace System.Runtime.Intrinsics.LoongArch;

    // SIMD-128bits.
    public abstract class Lsx : LoongArchBase
    {
        internal Lsx() { }
        public static new bool IsSupported { get => IsSupported; }
        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right);
        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right);
        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<long> Add(Vector64<long> left, Vector64<long> right);
        public static Vector64<ulong> Add(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right);
        public static Vector64<double> Add(Vector64<double> left, Vector64<double> right);
        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right);
        public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right);
        public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right);
        public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right);
        public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right);
        public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right);
        public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right);
        public static Vector64<long> AddSaturate(Vector64<long> left, Vector64<ulong> right);
        public static Vector64<ulong> AddSaturate(Vector64<ulong> left, Vector64<long> right);
        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right);
        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right);
        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> AddOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<ushort> AddOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<int> AddOddEvenElementsWidening(Vector128<short> left, Vector128<short> right);
        public static Vector128<uint> AddOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<long> AddOddEvenElementsWidening(Vector128<int> left, Vector128<int> right);
        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> AddOddEvenElementsWidening(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> AddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<ushort> AddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<int> AddEvenElementsWidening(Vector128<short> left, Vector128<short> right);
        public static Vector128<uint> AddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<long> AddEvenElementsWidening(Vector128<int> left, Vector128<int> right);
        public static Vector128<ulong> AddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> AddEvenElementsWidening(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> AddOddElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<ushort> AddOddElementsWidening(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<int> AddOddElementsWidening(Vector128<short> left, Vector128<short> right);
        public static Vector128<uint> AddOddElementsWidening(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<long> AddOddElementsWidening(Vector128<int> left, Vector128<int> right);
        public static Vector128<ulong> AddOddElementsWidening(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> AddOddElementsWidening(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AddOddElementsWidening(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> AddEvenElementsWidening(Vector128<byte> left, Vector128<sbyte> right);
        public static Vector128<int> AddEvenElementsWidening(Vector128<ushort> left, Vector128<short> right);
        public static Vector128<long> AddEvenElementsWidening(Vector128<uint> left, Vector128<int> right);
        public static Vector128<long> AddEvenElementsWidening(Vector128<ulong> left, Vector128<long> right);
        public static Vector128<short> AddOddElementsWidening(Vector128<byte> left, Vector128<sbyte> right);
        public static Vector128<int> AddOddElementsWidening(Vector128<ushort> left, Vector128<short> right);
        public static Vector128<long> AddOddElementsWidening(Vector128<uint> left, Vector128<int> right);
        public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right);
        public static Vector128<long> AddHorizontalElements(Vector128<sbyte> value);
        public static Vector128<ulong> AddHorizontalElements(Vector128<byte> value);
        public static Vector128<long> AddHorizontalElements(Vector128<short> value);
        public static Vector128<ulong> AddHorizontalElements(Vector128<ushort> value);
        public static Vector128<long> AddHorizontalElements(Vector128<int> value);
        public static Vector128<long> AddHorizontalElements(Vector128<uint> value);
        public static Vector128<long> AddHorizontalElements(Vector128<long> value);
        public static Vector128<ulong> AddHorizontalElements(Vector128<ulong> value);
        public static Vector64<float> AddHorizontalElements(Vector128<float> value);
        public static Vector64<double> AddHorizontalElements(Vector128<double> value);
        public static Vector64<sbyte> Subtract(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<byte> Subtract(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<short> Subtract(Vector64<short> left, Vector64<short> right);
        public static Vector64<ushort> Subtract(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<int> Subtract(Vector64<int> left, Vector64<int> right);
        public static Vector64<uint> Subtract(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<long> Subtract(Vector64<long> left, Vector64<long> right);
        public static Vector64<ulong> Subtract(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector64<float> Subtract(Vector64<float> left, Vector64<float> right);
        public static Vector64<double> Subtract(Vector64<double> left, Vector64<double> right);
        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> SubtractOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> SubtractOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> SubtractOddEvenElementsWidening(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> SubtractOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> SubtractOddEvenElementsWidening(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> SubtractOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> SubtractOddEvenElementsWidening(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> SubtractOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> MultiplyHight(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> MultiplyHight(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> MultiplyHight(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Divide(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Divide(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Divide(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> Modulo(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Modulo(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Modulo(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Modulo(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Modulo(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Modulo(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Modulo(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Modulo(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> FusedMultiplyAdd(Vector128<float> left, Vector128<float> right, Vector128<float> addend);
        public static Vector128<double> FusedMultiplyAdd(Vector128<double> left, Vector128<double> right, Vector128<double> addend);
        public static Vector128<float> FusedMultiplyAddNegated(Vector128<float> left, Vector128<float> right, Vector128<float> addend);
        public static Vector128<double> FusedMultiplyAddNegated(Vector128<double> left, Vector128<double> right, Vector128<double> addend);
        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> MultiplyAdd(Vector128<long> minuend, Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> MultiplyAdd(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> FusedMultiplySubtract(Vector128<float> left, Vector128<float> right, Vector128<float> minuend);
        public static Vector128<double> FusedMultiplySubtract(Vector128<double> left, Vector128<double> right, Vector128<double> minuend);
        public static Vector128<float> FusedMultiplySubtractNegated(Vector128<float> left, Vector128<float> right, Vector128<float> minuend);
        public static Vector128<double> FusedMultiplySubtractNegated(Vector128<double> left, Vector128<double> right, Vector128<double> minuend);
        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> MultiplySubtract(Vector128<byte> minuend, Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> MultiplySubtract(Vector128<long> minuend, Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> MultiplySubtract(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> MultiplyWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector128<ushort> MultiplyWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right);
        public static Vector128<int> MultiplyWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right);
        public static Vector128<uint> MultiplyWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right);
        public static Vector128<long> MultiplyWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right);
        public static Vector128<ulong> MultiplyWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right);
        public static Vector128<short> MultiplyWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<ushort> MultiplyWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right);
        public static Vector128<int> MultiplyWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right);
        public static Vector128<uint> MultiplyWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right);
        public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right);
        public static Vector128<sbyte> CompareNotEqualZero(Vector128<sbyte> value);
        public static Vector128<byte> CompareNotEqualZero(Vector128<byte> value);
        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<short> CompareEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<int> CompareEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<long> CompareEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<int> CompareEqual(Vector128<float> left, Vector128<float> right);
        public static Vector128<long> CompareEqual(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> CompareLessThanZero(Vector128<sbyte> value);
        public static Vector128<short> CompareLessThanZero(Vector128<short> value);
        public static Vector128<int> CompareLessThanZero(Vector128<int> value);
        public static Vector128<long> CompareLessThanZero(Vector128<long> value);
        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<short> CompareLessThan(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<int> CompareLessThan(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<long> CompareLessThan(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<int> CompareLessThan(Vector128<float> left, Vector128<float> right);
        public static Vector128<long> CompareLessThan(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right);
        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right);
        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<int> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right);
        public static Vector128<long> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right);
        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right);
        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<int> CompareGreaterThan(Vector128<float> left, Vector128<float> right);
        public static Vector128<long> CompareGreaterThan(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> CompareGreaterThanOrEqualZero(Vector128<sbyte> value);
        public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right);
        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> Max(Vector128<sbyte> value, const sbyte si5);
        public static Vector128<byte> Max(Vector128<byte> value, const byte ui5);
        public static Vector128<short> Max(Vector128<short> value, const sbyte si5);
        public static Vector128<ushort> Max(Vector128<ushort> value, const byte ui5);
        public static Vector128<int> Max(Vector128<int> value, const sbyte si5);
        public static Vector128<uint> Max(Vector128<uint> value, const byte ui5);
        public static Vector128<long> Max(Vector128<long> value, const sbyte si5);
        public static Vector128<ulong> Max(Vector128<ulong> value, const byte ui5);
        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);
        public static Vector128<float> MaxFloatAbsolute(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> MaxFloatAbsolute(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> Min(Vector128<sbyte> value, const sbyte si5);
        public static Vector128<byte> Min(Vector128<byte> value, const byte ui5);
        public static Vector128<short> Min(Vector128<short> value, const sbyte si5);
        public static Vector128<ushort> Min(Vector128<ushort> value, const byte ui5);
        public static Vector128<int> Min(Vector128<int> value, const sbyte si5);
        public static Vector128<uint> Min(Vector128<uint> value, const byte ui5);
        public static Vector128<long> Min(Vector128<long> value, const sbyte si5);
        public static Vector128<ulong> Min(Vector128<ulong> value, const byte ui5);
        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);
        public static Vector128<float> MinFloatAbsolute(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> MinFloatAbsolute(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> BitwiseSelect(Vector128<sbyte> select, Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> BitwiseSelect(Vector128<byte> select, Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> BitwiseSelect(Vector128<short> select, Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> BitwiseSelect(Vector128<ushort> select, Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> BitwiseSelect(Vector128<int> select, Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> BitwiseSelect(Vector128<uint> select, Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> BitwiseSelect(Vector128<long> select, Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> BitwiseSelect(Vector128<ulong> select, Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> BitwiseSelect(Vector128<float> select, Vector128<float> left, Vector128<float> right);
        public static Vector128<double> BitwiseSelect(Vector128<double> select, Vector128<double> left, Vector128<double> right);
        public static Vector128<byte> AbsoluteDifference(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> AbsoluteDifference(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<ushort> AbsoluteDifference(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<ulong> AbsoluteDifference(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AbsoluteDifference(Vector128<ulong> left, Vector128<ulong> 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);
        ///// <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);
        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<byte> LoadVector128(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<short> LoadVector128(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<ushort> LoadVector128(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<int> LoadVector128(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<uint> LoadVector128(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<long> LoadVector128(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<ulong> LoadVector128(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<float> LoadVector128(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<double> LoadVector128(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, long offsetValue);
        public static unsafe Vector128<byte> LoadVector128(byte* address, long offsetValue);
        public static unsafe Vector128<short> LoadVector128(short* address, long offsetValue);
        public static unsafe Vector128<ushort> LoadVector128(ushort* address, long offsetValue);
        public static unsafe Vector128<int> LoadVector128(int* address, long offsetValue);
        public static unsafe Vector128<uint> LoadVector128(uint* address, long offsetValue);
        public static unsafe Vector128<long> LoadVector128(long* address, long offsetValue);
        public static unsafe Vector128<ulong> LoadVector128(ulong* address, long offsetValue);
        public static unsafe Vector128<float> LoadVector128(float* address, long offsetValue);
        public static unsafe Vector128<double> LoadVector128(double* address, long offsetValue);
        public static unsafe Vector128<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector128<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static Vector128<float> Reciprocal(Vector128<float> value);
        public static Vector128<double> Reciprocal(Vector128<double> value);
        public static Vector128<float> ReciprocalSqrt(Vector128<float> value);
        public static Vector128<double> ReciprocalSqrt(Vector128<double> value);
        public static Vector128<float> Sqrt(Vector128<float> value);
        public static Vector128<double> Sqrt(Vector128<double> value);
        public static Vector128<float> FloatLogarithm2(Vector128<float> value);
        public static Vector128<double> FloatLogarithm2(Vector128<double> value);
        public static unsafe void Store(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector128<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void StoreElement(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx);
        public static unsafe void StoreElement(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx);
        public static unsafe void StoreElement(Vector128<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx);
        public static unsafe void StoreElement(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx);
        public static unsafe void StoreElement(Vector128<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static unsafe void StoreElement(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static unsafe void StoreElement(Vector128<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx);
        public static unsafe void StoreElement(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx);
        public static unsafe void StoreElement(Vector128<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static unsafe void StoreElement(Vector128<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx);
        public static Vector128<sbyte> Negate(Vector128<sbyte> value);
        public static Vector128<short> Negate(Vector128<short> value);
        public static Vector128<int> Negate(Vector128<int> value);
        public static Vector128<long> Negate(Vector128<long> value);
        public static Vector128<float> Negate(Vector128<float> value);
        public static Vector128<double> Negate(Vector128<double> value);
        public static Vector64<double> NegateScalar(Vector64<double> value);
        public static Vector64<float> NegateScalar(Vector64<float> value);
        public static Vector128<short> MultiplyWideningOdd(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<int> MultiplyWideningOdd(Vector128<short> left, Vector128<short> right);
        public static Vector128<long> MultiplyWideningOdd(Vector128<int> left, Vector128<int> right);
        public static Vector128<long> MultiplyWideningOdd(Vector128<long> left, Vector128<long> right);
        public static Vector128<short> MultiplyWideningEven(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<int> MultiplyWideningEven(Vector128<short> left, Vector128<short> right);
        public static Vector128<long> MultiplyWideningEven(Vector128<int> left, Vector128<int> right);
        public static Vector128<long> MultiplyWideningEven(Vector128<long> left, Vector128<long> right);
        public static Vector128<ushort> MultiplyWideningOdd(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<uint> MultiplyWideningOdd(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<ulong> MultiplyWideningOdd(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<ulong> MultiplyWideningOdd(Vector128<ulong> left, Vector128<ulong> 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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        public static Vector128<sbyte> Average(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Average(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Average(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Average(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> AverageRounded(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> AverageRounded(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> AverageRounded(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> AverageRounded(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> AverageRounded(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> AverageRounded(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> AverageRounded(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AverageRounded(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<short> SignExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift);
        public static Vector128<int> SignExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift);
        public static Vector128<long> SignExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift);
        public static Vector128<ushort> ZeroExtendWideningLowerAndShiftLeft(Vector64<byte> value, byte shift);
        public static Vector128<short> ZeroExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift);
        public static Vector128<uint> ZeroExtendWideningLowerAndShiftLeft(Vector64<ushort> value, byte shift);
        public static Vector128<int> ZeroExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift);
        public static Vector128<ulong> ZeroExtendWideningLowerAndShiftLeft(Vector64<uint> value, byte shift);
        public static Vector128<long> ZeroExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift);
        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<long> value);
        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<ulong> value);
        public static Vector128<short> SignExtendWideningUpper(Vector128<sbyte> value);
        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value);
        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value);
        public static Vector128<long> SignExtendWideningUpper(Vector128<long> value);
        public static Vector128<short> ZeroExtendWideningUpper(Vector128<sbyte> value);
        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value);
        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value);
        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value);
        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value);
        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value);
        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<long> value);
        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<ulong> value);
        public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> And(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> And(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> And(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> And(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> And(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right);
        public static Vector64<byte> Or(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<double> Or(Vector64<double> left, Vector64<double> right);
        public static Vector64<short> Or(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> Or(Vector64<int> left, Vector64<int> right);
        public static Vector64<long> Or(Vector64<long> left, Vector64<long> right);
        public static Vector64<sbyte> Or(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<float> Or(Vector64<float> left, Vector64<float> right);
        public static Vector64<ushort> Or(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<uint> Or(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<ulong> Or(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Or(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Or(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Or(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Or(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Or(Vector128<double> left, Vector128<double> right);
        public static Vector64<byte> Not(Vector64<byte> value);
        public static Vector64<double> Not(Vector64<double> value);
        public static Vector64<short> Not(Vector64<short> value);
        public static Vector64<int> Not(Vector64<int> value);
        public static Vector64<long> Not(Vector64<long> value);
        public static Vector64<sbyte> Not(Vector64<sbyte> value);
        public static Vector64<float> Not(Vector64<float> value);
        public static Vector64<ushort> Not(Vector64<ushort> value);
        public static Vector64<uint> Not(Vector64<uint> value);
        public static Vector64<ulong> Not(Vector64<ulong> value);
        public static Vector128<byte> Not(Vector128<byte> value);
        public static Vector128<double> Not(Vector128<double> value);
        public static Vector128<short> Not(Vector128<short> value);
        public static Vector128<int> Not(Vector128<int> value);
        public static Vector128<long> Not(Vector128<long> value);
        public static Vector128<sbyte> Not(Vector128<sbyte> value);
        public static Vector128<float> Not(Vector128<float> value);
        public static Vector128<ushort> Not(Vector128<ushort> value);
        public static Vector128<uint> Not(Vector128<uint> value);
        public static Vector128<ulong> Not(Vector128<ulong> value);
        public static Vector128<sbyte> NotOr(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> NotOr(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> NotOr(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> NotOr(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> NotOr(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> NotOr(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> NotOr(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> NotOr(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> NotOr(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> NotOr(Vector128<double> left, Vector128<double> right);
        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right);
        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right);
        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right);
        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right);
        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector128<sbyte> OrNot(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> OrNot(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> OrNot(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> OrNot(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> OrNot(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> OrNot(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> OrNot(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> OrNot(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> OrNot(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> OrNot(Vector128<double> left, Vector128<double> right);
        public static Vector64<byte> Xor(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<double> Xor(Vector64<double> left, Vector64<double> right);
        public static Vector64<short> Xor(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> Xor(Vector64<int> left, Vector64<int> right);
        public static Vector64<long> Xor(Vector64<long> left, Vector64<long> right);
        public static Vector64<sbyte> Xor(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<float> Xor(Vector64<float> left, Vector64<float> right);
        public static Vector64<ushort> Xor(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<uint> Xor(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<ulong> Xor(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right);
        public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right);
        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const byte shift);
        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, const byte shift);
        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, const byte shift);
        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, const byte shift);
        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, const byte shift);
        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, const byte shift);
        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, const byte shift);
        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, const byte shift);
        public static Vector128<sbyte> ShiftLeftLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<byte> ShiftLeftLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, Vector128<sbyte> shift);
        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, Vector128<byte> shift);
        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> shift);
        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> shift);
        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> shift);
        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> shift);
        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, const byte shift);
        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, const byte shift);
        public static Vector128<short> ShiftRightLogical(Vector128<short> value, const byte shift);
        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, const byte shift);
        public static Vector128<int> ShiftRightLogical(Vector128<int> value, const byte shift);
        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, const byte shift);
        public static Vector128<long> ShiftRightLogical(Vector128<long> value, const byte shift);
        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, const byte shift);
        public static Vector128<sbyte> ShiftRightLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<byte> ShiftRightLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, Vector128<sbyte> shift);
        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, Vector128<byte> shift);
        public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> shift);
        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> shift);
        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> shift);
        public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> shift);
        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, const byte shift);
        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, const byte shift);
        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, const byte shift);
        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, const byte shift);
        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, const byte shift);
        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, const byte shift);
        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, const byte shift);
        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, const byte shift);
        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, Vector128<sbyte> shift);
        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, Vector128<byte> shift);
        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, Vector128<short> shift);
        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, Vector128<int> shift);
        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, Vector128<uint> shift);
        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, Vector128<long> shift);
        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vsrlrni_d_q(int128x1_t left, int128x1_t right, const int n)
        /////   LSX: VSRLRNI.D.Q Vd, Vj, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift);
        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, const byte shift);
        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, const byte shift);
        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, const byte shift);
        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, const byte shift);
        public static Vector128<byte> ShiftRightArithmetic(Vector128<byte> value, Vector128<byte> shift);
        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> shift);
        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> shift);
        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> shift);
        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, const byte shift);
        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, const byte shift);
        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, const byte shift);
        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, const byte shift);
        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, Vector128<sbyte> shift);
        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, Vector128<short> shift);
        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, Vector128<int> shift);
        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, Vector128<long> shift);
        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vsrarni_d_q(int128x1_t left, int128x1_t right, const int n)
        /////   LSX: VSRARNI.D.Q Vd, Vj, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift);
        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, const byte shift);
        public static Vector128<byte> RotateRight(Vector128<byte> value, const byte shift);
        public static Vector128<short> RotateRight(Vector128<short> value, const byte shift);
        public static Vector128<ushort> RotateRight(Vector128<ushort> value, const byte shift);
        public static Vector128<int> RotateRight(Vector128<int> value, const byte shift);
        public static Vector128<uint> RotateRight(Vector128<uint> value, const byte shift);
        public static Vector128<long> RotateRight(Vector128<long> value, const byte shift);
        public static Vector128<ulong> RotateRight(Vector128<ulong> value, const byte shift);
        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, Vector128<sbyte> shift);
        public static Vector128<byte> RotateRight(Vector128<byte> value, Vector128<byte> shift);
        public static Vector128<short> RotateRight(Vector128<short> value, Vector128<short> shift);
        public static Vector128<ushort> RotateRight(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector128<int> RotateRight(Vector128<int> value, Vector128<int> shift);
        public static Vector128<uint> RotateRight(Vector128<uint> value, Vector128<uint> shift);
        public static Vector128<long> RotateRight(Vector128<long> value, Vector128<long> shift);
        public static Vector128<ulong> RotateRight(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<byte> Abs(Vector128<sbyte> value);
        public static Vector128<ushort> Abs(Vector128<short> value);
        public static Vector128<uint> Abs(Vector128<int> value);
        public static Vector128<ulong> Abs(Vector128<long> value);
        public static Vector128<float> Abs(Vector128<float> value);
        public static Vector128<double> Abs(Vector128<double> value);
        public static Vector128<float> Floor(Vector128<float> value);
        public static Vector128<double> Floor(Vector128<double> value);
        public static Vector128<float> Ceiling(Vector128<float> value);
        public static Vector128<double> Ceiling(Vector128<double> value);
        public static Vector128<float> RoundToZero(Vector128<float> value);
        public static Vector128<double> RoundToZero(Vector128<double> value);
        public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value);
        public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value);
        public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value);
        public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value);
        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, sbyte data, const byte index);
        public static Vector128<byte> Insert(Vector128<byte> vector, byte data, const byte index);
        public static Vector128<short> Insert(Vector128<short> vector, short data, const byte index);
        public static Vector128<ushort> Insert(Vector128<ushort> vector, ushort data, const byte index);
        public static Vector128<int> Insert(Vector128<int> vector, int data, const byte index);
        public static Vector128<uint> Insert(Vector128<uint> vector, uint data, const byte index);
        public static Vector128<long> Insert(Vector128<long> vector, long data, const byte index);
        public static Vector128<ulong> Insert(Vector128<ulong> vector, ulong data, const byte index);
        public static Vector128<float> Insert(Vector128<float> vector, float data, const byte index);
        public static Vector128<double> Insert(Vector128<double> vector, double data, const byte index);
        public static Vector128<sbyte> DuplicateToVector128(sbyte value);
        public static Vector128<byte> DuplicateToVector128(byte value);
        public static Vector128<short> DuplicateToVector128(short value);
        public static Vector128<ushort> DuplicateToVector128(ushort value);
        public static Vector128<int> DuplicateToVector128(int value);
        public static Vector128<uint> DuplicateToVector128(uint value);
        public static Vector128<long> DuplicateToVector128(long value);
        public static Vector128<ulong> DuplicateToVector128(ulong value);
        public static Vector128<float> DuplicateToVector128(float value);
        public static Vector128<double> DuplicateToVector128(double value);
        public static Vector128<float> ConvertToSingle(Vector128<int> value);
        public static Vector128<float> ConvertToSingle(Vector128<uint> value);
        public static Vector128<double> ConvertToDouble(Vector128<long> value);
        public static Vector128<double> ConvertToDouble(Vector128<ulong> value);
        public static byte FirstNegativeInteger(Vector128<byte> value);
        public static ushort FirstNegativeInteger(Vector128<ushort> value);
        public static bool HasElementsNotZero(Vector128<byte> value);
        public static bool AllElementsIsZero(Vector128<byte> value);
        public static bool AllElementsNotZero(Vector128<sbyte> value);
        public static bool AllElementsNotZero(Vector128<byte> value);
        public static bool AllElementsNotZero(Vector128<short> value);
        public static bool AllElementsNotZero(Vector128<ushort> value);
        public static bool AllElementsNotZero(Vector128<int> value);
        public static bool AllElementsNotZero(Vector128<uint> value);
        public static bool AllElementsNotZero(Vector128<long> value);
        public static bool AllElementsNotZero(Vector128<ulong> value);
        public static bool HasElementsIsZero(Vector128<sbyte> value);
        public static bool HasElementsIsZero(Vector128<byte> value);
        public static bool HasElementsIsZero(Vector128<short> value);
        public static bool HasElementsIsZero(Vector128<ushort> value);
        public static bool HasElementsIsZero(Vector128<int> value);
        public static bool HasElementsIsZero(Vector128<uint> value);
        public static bool HasElementsIsZero(Vector128<long> value);
        public static bool HasElementsIsZero(Vector128<ulong> value);
        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift);
        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift);
        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift);
        ///// <summary>
        ///// uint64x2_t vsrlni_d_q(uint128x1_t left, uint128x1_t right, shift)
        /////   LSX: VSRLNI.D.Q Vd.Q, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<ulong> ShiftRightLogicalNarrowingLower(Vector128<ulonglong> left, Vector128<ulonglong> right, byte shift);
        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, Vector128<long> shift);
        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vssrlni_d_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRLNI.D.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightLogicalNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift);
        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x2_t vssrlni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
        /////   LSX: VSSRLNI.DU.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vssran_d_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRANI.D.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightArithmeticNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift);
        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x2_t vssrani_du_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRANI.DU.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift);
        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vssrlrni_d_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRLRNI.D.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift);
        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x2_t vssrlrni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
        /////   LSX: VSSRLRNI.DU.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift);
        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift);
        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift);
        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x2_t vssrarn_d_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRARNI.D.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift);
        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x2_t vssrarni_du_q(int128x1_t left, int128x1_t right, const byte n)
        /////   LSX: VSSRARNI.DU.Q Vd.2D, Vj.Q, ui7
        ///// </summary>
        //public static Vector128<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift);
        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift);
        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift);
        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value);
        public static Vector64<short> LeadingSignCount(Vector64<short> value);
        public static Vector64<int> LeadingSignCount(Vector64<int> value);
        public static Vector64<long> LeadingSignCount(Vector64<long> value);
        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value);
        public static Vector128<short> LeadingSignCount(Vector128<short> value);
        public static Vector128<int> LeadingSignCount(Vector128<int> value);
        public static Vector128<long> LeadingSignCount(Vector128<long> value);
        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value);
        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value);
        public static Vector64<short> LeadingZeroCount(Vector64<short> value);
        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value);
        public static Vector64<int> LeadingZeroCount(Vector64<int> value);
        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value);
        public static Vector64<long> LeadingZeroCount(Vector64<long> value);
        public static Vector64<ulong> LeadingZeroCount(Vector64<ulong> value);
        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value);
        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value);
        public static Vector128<short> LeadingZeroCount(Vector128<short> value);
        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value);
        public static Vector128<int> LeadingZeroCount(Vector128<int> value);
        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);
        public static Vector128<long> LeadingZeroCount(Vector128<long> value);
        public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value);
        public static Vector128<sbyte> PopCount(Vector128<sbyte> value);
        public static Vector128<byte> PopCount(Vector128<byte> value);
        public static Vector128<short> PopCount(Vector128<short> value);
        public static Vector128<ushort> PopCount(Vector128<ushort> value);
        public static Vector128<int> PopCount(Vector128<int> value);
        public static Vector128<uint> PopCount(Vector128<uint> value);
        public static Vector128<long> PopCount(Vector128<long> value);
        public static Vector128<ulong> PopCount(Vector128<ulong> value);
        public static Vector128<byte> VectorShuffle(Vector128<byte> vector, Vector128<byte> indexs);
        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector, Vector128<sbyte> indexs);
        public static Vector128<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> indexs);
        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> indexs);
        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> indexs);
        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> indexs);
        public static Vector128<int> VectorShuffle(Vector128<int> vector, const byte indexs);
        public static Vector128<uint> VectorShuffle(Vector128<uint> vector, const byte indexs);
        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> indexs);
        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> indexs);
        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> indexs);
        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> indexs);
        public static Vector128<sbyte> VectorShuffleBy4Elements(Vector128<sbyte> vector, byte indexs);
        public static Vector128<byte> VectorShuffleBy4Elements(Vector128<byte> vector, byte indexs);
        public static Vector128<short> VectorShuffleBy4Elements(Vector128<short> vector, byte indexs);
        public static Vector128<ushort> VectorShuffleBy4Elements(Vector128<ushort> vector, byte indexs);
        public static Vector128<int> VectorShuffleBy4Elements(Vector128<int> vector, byte indexs);
        public static Vector128<uint> VectorShuffleBy4Elements(Vector128<uint> vector, byte indexs);
        public static Vector128<long> VectorShuffleBy4Elements(Vector128<long> vector0, Vector128<long> vector1, byte indexs);
        public static Vector128<ulong> VectorShuffleBy4Elements(Vector128<ulong> vector0, Vector128<ulong> vector1, byte indexs);
        public static Vector128<sbyte> VectorElementsFusionLower(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorElementsFusionLower(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorElementsFusionLower(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorElementsFusionLower(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorElementsFusionLower(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorElementsFusionLower(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorElementsFusionLower(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorElementsFusionLower(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> VectorElementsFusionHight(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorElementsFusionHight(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorElementsFusionHight(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorElementsFusionHight(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorElementsFusionHight(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorElementsFusionHight(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorElementsFusionHight(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorElementsFusionHight(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> VectorElementsFusionEven(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorElementsFusionEven(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorElementsFusionEven(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorElementsFusionEven(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorElementsFusionEven(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorElementsFusionEven(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorElementsFusionEven(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorElementsFusionEven(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> VectorElementsFusionOdd(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorElementsFusionOdd(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorElementsFusionOdd(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorElementsFusionOdd(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorElementsFusionOdd(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorElementsFusionOdd(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorElementsFusionOdd(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorElementsFusionOdd(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> VectorEvenElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorEvenElementsJoin(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorEvenElementsJoin(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorEvenElementsJoin(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorEvenElementsJoin(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorEvenElementsJoin(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorEvenElementsJoin(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorEvenElementsJoin(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<sbyte> VectorOddElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector128<byte> VectorOddElementsJoin(Vector128<byte> left, Vector128<byte> right);
        public static Vector128<short> VectorOddElementsJoin(Vector128<short> left, Vector128<short> right);
        public static Vector128<ushort> VectorOddElementsJoin(Vector128<ushort> left, Vector128<ushort> right);
        public static Vector128<int> VectorOddElementsJoin(Vector128<int> left, Vector128<int> right);
        public static Vector128<uint> VectorOddElementsJoin(Vector128<uint> left, Vector128<uint> right);
        public static Vector128<long> VectorOddElementsJoin(Vector128<long> left, Vector128<long> right);
        public static Vector128<ulong> VectorOddElementsJoin(Vector128<ulong> left, Vector128<ulong> right);
        public static Vector128<byte> VectorElementReplicate(Vector128<byte> vector, byte elementIndexe);
        public static Vector128<sbyte> VectorElementReplicate(Vector128<sbyte> vector, byte elementIndexe);
        public static Vector128<short> VectorElementReplicate(Vector128<short> vector, byte elementIndexe);
        public static Vector128<ushort> VectorElementReplicate(Vector128<ushort> vector, byte elementIndexe);
        public static Vector128<int> VectorElementReplicate(Vector128<int> vector, byte elementIndexe);
        public static Vector128<uint> VectorElementReplicate(Vector128<uint> vector, byte elementIndexe);
        public static Vector128<long> VectorElementReplicate(Vector128<long> vector, byte elementIndexe);
        public static Vector128<ulong> VectorElementReplicate(Vector128<ulong> vector, byte elementIndexe);
        public static Vector128<sbyte> UpdateOneVectorElement(Vector128<sbyte> vector, const byte indexs);
        public static Vector128<byte> UpdateOneVectorElement(Vector128<byte> vector, const byte indexs);
        public static Vector128<short> UpdateOneVectorElement(Vector128<short> vector, const byte indexs);
        public static Vector128<ushort> UpdateOneVectorElement(Vector128<ushort> vector, const byte indexs);
        public static Vector128<int> UpdateOneVectorElement(Vector128<int> vector, const byte indexs);
        public static Vector128<uint> UpdateOneVectorElement(Vector128<uint> vector, const byte indexs);
        public static Vector128<long> UpdateOneVectorElement(Vector128<long> vector, const byte indexs);
        public static Vector128<ulong> UpdateOneVectorElement(Vector128<ulong> vector, const byte indexs);
        public static Vector128<sbyte> VectorElementNegatedBySign(Vector128<sbyte> sign, Vector128<sbyte> data);
        public static Vector128<short> VectorElementNegatedBySign(Vector128<short> sign, Vector128<short> data);
        public static Vector128<int> VectorElementNegatedBySign(Vector128<int> sign, Vector128<int> data);
        public static Vector128<long> VectorElementNegatedBySign(Vector128<long> sign, Vector128<long> data);
        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, const byte index);
        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, const byte index);
        public static Vector128<short> VectorElementBitClear(Vector128<short> value, const byte index);
        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, const byte index);
        public static Vector128<int> VectorElementBitClear(Vector128<int> value, const byte index);
        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, const byte index);
        public static Vector128<long> VectorElementBitClear(Vector128<long> value, const byte index);
        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, const byte index);
        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, Vector128<sbyte> index);
        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, Vector128<byte> index);
        public static Vector128<short> VectorElementBitClear(Vector128<short> value, Vector128<short> index);
        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, Vector128<ushort> index);
        public static Vector128<int> VectorElementBitClear(Vector128<int> value, Vector128<int> index);
        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, Vector128<uint> index);
        public static Vector128<long> VectorElementBitClear(Vector128<long> value, Vector128<long> index);
        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, Vector128<ulong> index);
        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, const byte index);
        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, const byte index);
        public static Vector128<short> VectorElementBitSet(Vector128<short> value, const byte index);
        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, const byte index);
        public static Vector128<int> VectorElementBitSet(Vector128<int> value, const byte index);
        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, const byte index);
        public static Vector128<long> VectorElementBitSet(Vector128<long> value, const byte index);
        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, const byte index);
        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, Vector128<sbyte> index);
        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, Vector128<byte> index);
        public static Vector128<short> VectorElementBitSet(Vector128<short> value, Vector128<short> index);
        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, Vector128<ushort> index);
        public static Vector128<int> VectorElementBitSet(Vector128<int> value, Vector128<int> index);
        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, Vector128<uint> index);
        public static Vector128<long> VectorElementBitSet(Vector128<long> value, Vector128<long> index);
        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, Vector128<ulong> index);
        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, const byte index);
        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, const byte index);
        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, const byte index);
        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, const byte index);
        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, const byte index);
        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, const byte index);
        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, const byte index);
        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, const byte index);
        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, Vector128<sbyte> index);
        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, Vector128<byte> index);
        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, Vector128<short> index);
        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, Vector128<ushort> index);
        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, Vector128<int> index);
        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, Vector128<uint> index);
        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, Vector128<long> index);
        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, Vector128<ulong> index);
        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, Vector128<sbyte> save);
        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, Vector128<short> save);
        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, const byte save);
        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, const byte save);
        public static Vector128<sbyte> VectorSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits);
        public static Vector128<short> VectorSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte bits);
        public static Vector128<int> VectorSaturate(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte bits);
        public static Vector128<long> VectorSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte bits);
        public static Vector128<byte> VectorSaturateUnsigned(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits);
        public static Vector128<ushort> VectorSaturateUnsigned(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits);
        public static Vector128<uint> VectorSaturateUnsigned(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits);
        public static Vector128<ulong> VectorSaturateUnsigned(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits);
        public static Vector128<int> FloatClass(Vector128<float> value);
        public static Vector128<long> FloatClass(Vector128<double> value);
    }

@shushanhf
Copy link
Contributor Author

shushanhf commented Feb 18, 2024 •
edited
Loading

Click to expand 'public abstract class Lasx : Lsx' 
namespace System.Runtime.Intrinsics.LoongArch;

    // SIMD-256bits.
    public abstract class Lasx : Lsx
    {
        internal Lasx() { }
        public static new bool IsSupported { get => IsSupported; }
        public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Add(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Add(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Add(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Add(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right);
        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right);
        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<long> right);
        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> AddOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> AddOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> AddOddEvenElementsWidening(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> AddOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> AddOddEvenElementsWidening(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> AddOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> AddOddEvenElementsWidening(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AddOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<short> AddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<ushort> AddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<int> AddEvenElementsWidening(Vector256<short> left, Vector256<short> right);
        public static Vector256<uint> AddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<long> AddEvenElementsWidening(Vector256<int> left, Vector256<int> right);
        public static Vector256<ulong> AddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> AddEvenElementsWidening(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<short> AddOddElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<ushort> AddOddElementsWidening(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<int> AddOddElementsWidening(Vector256<short> left, Vector256<short> right);
        public static Vector256<uint> AddOddElementsWidening(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<long> AddOddElementsWidening(Vector256<int> left, Vector256<int> right);
        public static Vector256<ulong> AddOddElementsWidening(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> AddOddElementsWidening(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AddOddElementsWidening(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<short> AddEvenElementsWidening(Vector256<byte> left, Vector256<sbyte> right);
        public static Vector256<int> AddEvenElementsWidening(Vector256<ushort> left, Vector256<short> right);
        public static Vector256<long> AddEvenElementsWidening(Vector256<uint> left, Vector256<int> right);
        public static Vector256<long> AddEvenElementsWidening(Vector256<ulong> left, Vector256<long> right);
        public static Vector256<short> AddOddElementsWidening(Vector256<byte> left, Vector256<sbyte> right);
        public static Vector256<int> AddOddElementsWidening(Vector256<ushort> left, Vector256<short> right);
        public static Vector256<long> AddOddElementsWidening(Vector256<uint> left, Vector256<int> right);
        public static Vector256<long> AddOddElementsWidening(Vector256<ulong> left, Vector256<long> right);
        public static Vector128<long> AddHorizontalElements(Vector256<sbyte> value);
        public static Vector128<ulong> AddHorizontalElements(Vector256<byte> value);
        public static Vector128<long> AddHorizontalElements(Vector256<short> value);
        public static Vector128<ulong> AddHorizontalElements(Vector256<ushort> value);
        public static Vector128<long> AddHorizontalElements(Vector256<int> value);
        public static Vector128<long> AddHorizontalElements(Vector256<uint> value);
        public static Vector128<long> AddHorizontalElements(Vector256<long> value);
        public static Vector128<ulong> AddHorizontalElements(Vector256<ulong> value);
        public static Vector64<float> AddHorizontalElements(Vector256<float> value);
        public static Vector64<double> AddHorizontalElements(Vector256<double> value);
        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> SubtractOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> SubtractOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> SubtractOddEvenElementsWidening(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> SubtractOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> SubtractOddEvenElementsWidening(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> SubtractOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> SubtractOddEvenElementsWidening(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> SubtractOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> SubtractSaturate(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> SubtractSaturate(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Multiply(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Multiply(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Multiply(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Multiply(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Multiply(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> MultiplyHight(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> MultiplyHight(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> MultiplyHight(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> MultiplyHight(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> MultiplyHight(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> MultiplyHight(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> MultiplyHight(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> MultiplyHight(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> Divide(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Divide(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Divide(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Divide(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Divide(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Divide(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> Modulo(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Modulo(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Modulo(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Modulo(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Modulo(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Modulo(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Modulo(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Modulo(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> FusedMultiplyAdd(Vector256<float> left, Vector256<float> right, Vector256<float> addend);
        public static Vector256<double> FusedMultiplyAdd(Vector256<double> left, Vector256<double> right, Vector256<double> addend);
        public static Vector256<float> FusedMultiplyAddNegated(Vector256<float> left, Vector256<float> right, Vector256<float> addend);
        public static Vector256<double> FusedMultiplyAddNegated(Vector256<double> left, Vector256<double> right, Vector256<double> addend);
        public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> MultiplyAdd(Vector256<byte> addend, Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> MultiplyAdd(Vector256<short> addend, Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> MultiplyAdd(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> MultiplyAdd(Vector256<long> addend, Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> MultiplyAdd(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> FusedMultiplySubtract(Vector256<float> left, Vector256<float> right, Vector256<float> minuend);
        public static Vector256<double> FusedMultiplySubtract(Vector256<double> left, Vector256<double> right, Vector256<double> minuend);
        public static Vector256<float> FusedMultiplySubtractNegated(Vector256<float> left, Vector256<float> right, Vector256<float> minuend);
        public static Vector256<double> FusedMultiplySubtractNegated(Vector256<double> left, Vector256<double> right, Vector256<double> minuend);
        public static Vector256<sbyte> MultiplySubtract(Vector256<sbyte> minuend, Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> MultiplySubtract(Vector256<byte> minuend, Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> MultiplySubtract(Vector256<short> minuend, Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> MultiplySubtract(Vector256<ushort> minuend, Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> MultiplySubtract(Vector256<long> addend, Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> MultiplySubtract(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<short> MultiplyWideningLowerAndAdd(Vector256<short> addend, Vector128<sbyte> left, Vector128<sbyte> right);
        public static Vector256<ushort> MultiplyWideningLowerAndAdd(Vector256<ushort> addend, Vector128<byte> left, Vector128<byte> right);
        public static Vector256<int> MultiplyWideningLowerAndAdd(Vector256<int> addend, Vector128<short> left, Vector128<short> right);
        public static Vector256<uint> MultiplyWideningLowerAndAdd(Vector256<uint> addend, Vector128<ushort> left, Vector128<ushort> right);
        public static Vector256<long> MultiplyWideningLowerAndAdd(Vector256<long> addend, Vector128<int> left, Vector128<int> right);
        public static Vector256<ulong> MultiplyWideningLowerAndAdd(Vector256<ulong> addend, Vector128<uint> left, Vector128<uint> right);
        public static Vector256<short> MultiplyWideningUpperAndAdd(Vector256<short> addend, Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<ushort> MultiplyWideningUpperAndAdd(Vector256<ushort> addend, Vector256<byte> left, Vector256<byte> right);
        public static Vector256<int> MultiplyWideningUpperAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right);
        public static Vector256<uint> MultiplyWideningUpperAndAdd(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<long> MultiplyWideningUpperAndAdd(Vector256<long> addend, Vector256<int> left, Vector256<int> right);
        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right);
        public static Vector256<sbyte> CompareNotEqualZeroEach128(Vector256<sbyte> value);
        public static Vector256<byte> CompareNotEqualZeroEach128(Vector256<byte> value);
        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<short> CompareEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<int> CompareEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<long> CompareEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> CompareLessThanZeroEach128(Vector256<sbyte> value);
        public static Vector256<short> CompareLessThanZeroEach128(Vector256<short> value);
        public static Vector256<int> CompareLessThanZeroEach128(Vector256<int> value);
        public static Vector256<long> CompareLessThanZeroEach128(Vector256<long> value);
        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<short> CompareLessThan(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<int> CompareLessThan(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<long> CompareLessThan(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5);
        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right);
        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right);
        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right);
        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> value, [ConstantExpected(Max = (byte)(31))] byte ui5);
        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<int> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right);
        public static Vector256<long> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> CompareGreaterThanOrEqualZeroEach128(Vector256<sbyte> value);
        public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> Max(Vector256<sbyte> value, const sbyte si5);
        public static Vector256<byte> Max(Vector256<byte> value, const byte ui5);
        public static Vector256<short> Max(Vector256<short> value, const sbyte si5);
        public static Vector256<ushort> Max(Vector256<ushort> value, const byte ui5);
        public static Vector256<int> Max(Vector256<int> value, const sbyte si5);
        public static Vector256<uint> Max(Vector256<uint> value, const byte ui5);
        public static Vector256<long> Max(Vector256<long> value, const sbyte si5);
        public static Vector256<ulong> Max(Vector256<ulong> value, const byte ui5);
        public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Max(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Max(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Max(Vector256<double> left, Vector256<double> right);
        public static Vector256<float> MaxFloatAbsolute(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> MaxFloatAbsolute(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> Min(Vector256<sbyte> value, const sbyte si5);
        public static Vector256<byte> Min(Vector256<byte> value, const byte ui5);
        public static Vector256<short> Min(Vector256<short> value, const sbyte si5);
        public static Vector256<ushort> Min(Vector256<ushort> value, const byte ui5);
        public static Vector256<int> Min(Vector256<int> value, const sbyte si5);
        public static Vector256<uint> Min(Vector256<uint> value, const byte ui5);
        public static Vector256<long> Min(Vector256<long> value, const sbyte si5);
        public static Vector256<ulong> Min(Vector256<ulong> value, const byte ui5);
        public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Min(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Min(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Min(Vector256<double> left, Vector256<double> right);
        public static Vector256<float> MinFloatAbsolute(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> MinFloatAbsolute(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> BitwiseSelect(Vector256<sbyte> select, Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> BitwiseSelect(Vector256<byte> select, Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> BitwiseSelect(Vector256<short> select, Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> BitwiseSelect(Vector256<ushort> select, Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> BitwiseSelect(Vector256<int> select, Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> BitwiseSelect(Vector256<uint> select, Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> BitwiseSelect(Vector256<long> select, Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> BitwiseSelect(Vector256<ulong> select, Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> BitwiseSelect(Vector256<float> select, Vector256<float> left, Vector256<float> right);
        public static Vector256<double> BitwiseSelect(Vector256<double> select, Vector256<double> left, Vector256<double> right);
        public static Vector256<byte> AbsoluteDifference(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> AbsoluteDifference(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<ushort> AbsoluteDifference(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> AbsoluteDifference(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<ulong> AbsoluteDifference(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AbsoluteDifference(Vector256<ulong> left, Vector256<ulong> 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);
        ///// <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);
        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<byte> LoadVector256(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<short> LoadVector256(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<ushort> LoadVector256(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<int> LoadVector256(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<uint> LoadVector256(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<long> LoadVector256(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<ulong> LoadVector256(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<float> LoadVector256(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<double> LoadVector256(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, long offsetValue);
        public static unsafe Vector256<byte> LoadVector256(byte* address, long offsetValue);
        public static unsafe Vector256<short> LoadVector256(short* address, long offsetValue);
        public static unsafe Vector256<ushort> LoadVector256(ushort* address, long offsetValue);
        public static unsafe Vector256<int> LoadVector256(int* address, long offsetValue);
        public static unsafe Vector256<uint> LoadVector256(uint* address, long offsetValue);
        public static unsafe Vector256<long> LoadVector256(long* address, long offsetValue);
        public static unsafe Vector256<ulong> LoadVector256(ulong* address, long offsetValue);
        public static unsafe Vector256<float> LoadVector256(float* address, long offsetValue);
        public static unsafe Vector256<double> LoadVector256(double* address, long offsetValue);
        public static unsafe Vector256<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe Vector256<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static Vector256<float> Reciprocal(Vector256<float> value);
        public static Vector256<double> Reciprocal(Vector256<double> value);
        public static Vector256<float> ReciprocalSqrt(Vector256<float> value);
        public static Vector256<double> ReciprocalSqrt(Vector256<double> value);
        public static Vector256<float> Sqrt(Vector256<float> value);
        public static Vector256<double> Sqrt(Vector256<double> value);
        public static Vector256<float> FloatLogarithm2(Vector256<float> value);
        public static Vector256<double> FloatLogarithm2(Vector256<double> value);
        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12);
        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, long offsetValue);
        public static unsafe void Store(Vector256<byte> vector, byte* addr, long offsetValue);
        public static unsafe void Store(Vector256<short> vector, short* addr, long offsetValue);
        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, long offsetValue);
        public static unsafe void Store(Vector256<int> vector, int* addr, long offsetValue);
        public static unsafe void Store(Vector256<uint> vector, uint* addr, long offsetValue);
        public static unsafe void Store(Vector256<long> vector, long* addr, long offsetValue);
        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, long offsetValue);
        public static unsafe void Store(Vector256<float> vector, float* addr, long offsetValue);
        public static unsafe void Store(Vector256<double> vector, double* addr, long offsetValue);
        public static unsafe void StoreElement(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx);
        public static unsafe void StoreElement(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx);
        public static unsafe void StoreElement(Vector256<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx);
        public static unsafe void StoreElement(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx);
        public static unsafe void StoreElement(Vector256<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx);
        public static unsafe void StoreElement(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx);
 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(Vector256<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static unsafe void StoreElement(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static unsafe void StoreElement(Vector256<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx);
        public static unsafe void StoreElement(Vector256<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx);
        public static Vector256<sbyte> Negate(Vector256<sbyte> value);
        public static Vector256<short> Negate(Vector256<short> value);
        public static Vector256<int> Negate(Vector256<int> value);
        public static Vector256<long> Negate(Vector256<long> value);
        public static Vector256<float> Negate(Vector256<float> value);
        public static Vector256<double> Negate(Vector256<double> value);
        public static Vector256<short> MultiplyWideningOdd(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<int> MultiplyWideningOdd(Vector256<short> left, Vector256<short> right);
        public static Vector256<long> MultiplyWideningOdd(Vector256<int> left, Vector256<int> right);
        public static Vector256<long> MultiplyWideningOdd(Vector256<long> left, Vector256<long> right);
        public static Vector256<short> MultiplyWideningEven(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<int> MultiplyWideningEven(Vector256<short> left, Vector256<short> right);
        public static Vector256<long> MultiplyWideningEven(Vector256<int> left, Vector256<int> right);
        public static Vector256<long> MultiplyWideningEven(Vector256<long> left, Vector256<long> right);
        public static Vector256<ushort> MultiplyWideningOdd(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<uint> MultiplyWideningOdd(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<ulong> MultiplyWideningOdd(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<ulong> MultiplyWideningOdd(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<ushort> MultiplyWideningEven(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<uint> MultiplyWideningEven(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<ulong> MultiplyWideningEven(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<ulong> MultiplyWideningEven(Vector256<ulong> left, Vector256<ulong> 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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        // /// <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);
        public static Vector256<sbyte> Average(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Average(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Average(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Average(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> AverageRounded(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> AverageRounded(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> AverageRounded(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> AverageRounded(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> AverageRounded(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> AverageRounded(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> AverageRounded(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AverageRounded(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift);
        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift);
        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift);
        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift);
        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift);
        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift);
        public static Vector256<ushort> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift);
        public static Vector256<short> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift);
        public static Vector256<uint> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift);
        public static Vector256<int> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift);
        public static Vector256<ulong> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift);
        public static Vector256<long> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift);
        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<long> value);
        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<ulong> value);
        public static Vector256<short> SignExtendWideningLower(Vector128<sbyte> value, byte shift);
        public static Vector256<short> SignExtendWideningLower(Vector128<byte> value, byte shift);
        public static Vector256<int> SignExtendWideningLower(Vector64<sbyte> value, byte shift);
        //public static Vector256<int> SignExtendWideningLower(Vector128<sbyte> value, byte shift);
        public static Vector256<int> SignExtendWideningLower(Vector64<byte> value, byte shift);
        //public static Vector256<int> SignExtendWideningLower(Vector128<byte> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector64<sbyte> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector64<byte> value, byte shift);
        public static Vector256<int> SignExtendWideningLower(Vector128<short> value, byte shift);
        public static Vector256<int> SignExtendWideningLower(Vector128<ushort> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector64<short> value, byte shift);
        //public static Vector256<long> SignExtendWideningLower(Vector128<short> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector64<ushort> value, byte shift);
        //public static Vector256<long> SignExtendWideningLower(Vector128<ushort> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector128<int> value, byte shift);
        public static Vector256<long> SignExtendWideningLower(Vector128<uint> value, byte shift);
        public static Vector256<ushort> ZeroExtendWideningLower(Vector128<byte> value, byte shift);
        public static Vector256<short> ZeroExtendWideningLower(Vector128<sbyte> value, byte shift);
        public static Vector256<uint> ZeroExtendWideningLower(Vector64<byte> value, byte shift);
        public static Vector256<int> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift);
        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<byte> value, byte shift);
        public static Vector256<long> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift);
        public static Vector256<uint> ZeroExtendWideningLower(Vector128<ushort> value, byte shift);
        public static Vector256<int> ZeroExtendWideningLower(Vector128<short> value, byte shift);
        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<ushort> value, byte shift);
        public static Vector256<long> ZeroExtendWideningLower(Vector64<short> value, byte shift);
        public static Vector256<ulong> ZeroExtendWideningLower(Vector128<uint> value, byte shift);
        public static Vector256<long> ZeroExtendWideningLower(Vector128<int> value, byte shift);
        public static Vector256<short> SignExtendWideningUpperEach128(Vector256<sbyte> value);
        public static Vector256<int> SignExtendWideningUpperEach128(Vector256<short> value);
        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<int> value);
        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<long> value);
        public static Vector256<short> ZeroExtendWideningUpperEach128(Vector256<sbyte> value);
        public static Vector256<ushort> ZeroExtendWideningUpperEach128(Vector256<byte> value);
        public static Vector256<int> ZeroExtendWideningUpperEach128(Vector256<short> value);
        public static Vector256<uint> ZeroExtendWideningUpperEach128(Vector256<ushort> value);
        public static Vector256<long> ZeroExtendWideningUpperEach128(Vector256<int> value);
        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<uint> value);
        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<long> value);
        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<ulong> value);
        public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> And(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> And(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> And(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> And(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> And(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Or(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Or(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Or(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Or(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Or(Vector256<double> left, Vector256<double> right);
        public static Vector256<byte> Not(Vector256<byte> value);
        public static Vector256<double> Not(Vector256<double> value);
        public static Vector256<short> Not(Vector256<short> value);
        public static Vector256<int> Not(Vector256<int> value);
        public static Vector256<long> Not(Vector256<long> value);
        public static Vector256<sbyte> Not(Vector256<sbyte> value);
        public static Vector256<float> Not(Vector256<float> value);
        public static Vector256<ushort> Not(Vector256<ushort> value);
        public static Vector256<uint> Not(Vector256<uint> value);
        public static Vector256<ulong> Not(Vector256<ulong> value);
        public static Vector256<sbyte> NotOr(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> NotOr(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> NotOr(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> NotOr(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> NotOr(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> NotOr(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> NotOr(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> NotOr(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> NotOr(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> NotOr(Vector256<double> left, Vector256<double> right);
        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right);
        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right);
        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right);
        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right);
        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right);
        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right);
        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right);
        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right);
        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right);
        public static Vector256<sbyte> OrNot(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> OrNot(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> OrNot(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> OrNot(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> OrNot(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> OrNot(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> OrNot(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> OrNot(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> OrNot(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> OrNot(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right);
        public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right);
        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, const byte shift);
        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, const byte shift);
        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, const byte shift);
        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, const byte shift);
        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, const byte shift);
        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, const byte shift);
        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, const byte shift);
        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, const byte shift);
        public static Vector256<sbyte> ShiftLeftLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<byte> ShiftLeftLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, Vector256<byte> shift);
        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector256<short> shift);
        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector256<int> shift);
        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector256<uint> shift);
        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector256<long> shift);
        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, const byte shift);
        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, const byte shift);
        public static Vector256<short> ShiftRightLogical(Vector256<short> value, const byte shift);
        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, const byte shift);
        public static Vector256<int> ShiftRightLogical(Vector256<int> value, const byte shift);
        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, const byte shift);
        public static Vector256<long> ShiftRightLogical(Vector256<long> value, const byte shift);
        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, const byte shift);
        public static Vector256<sbyte> ShiftRightLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<byte> ShiftRightLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, Vector256<byte> shift);
        public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector256<short> shift);
        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector256<int> shift);
        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector256<uint> shift);
        public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector256<long> shift);
        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, const byte shift);
        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, const byte shift);
        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, const byte shift);
        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, const byte shift);
        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, const byte shift);
        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, const byte shift);
        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, const byte shift);
        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, const byte shift);
        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, Vector256<byte> shift);
        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, Vector256<short> shift);
        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, Vector256<int> shift);
        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, Vector256<uint> shift);
        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, Vector256<long> shift);
        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvsrlrni_d_q(int128x2_t left, int128x2_t right, const int n)
        /////   LASX: XVSRLRNI.D.Q Xd, Xj, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvsrarni_d_q(int128x2_t left, int128x2_t right, const int n)
        /////   LASX: XVSRARNI.D.Q Xd, Xj, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, const byte shift);
        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, const byte shift);
        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, const byte shift);
        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, const byte shift);
        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector256<short> shift);
        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector256<int> shift);
        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector256<long> shift);
        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, const byte shift);
        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, const byte shift);
        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, const byte shift);
        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, const byte shift);
        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, Vector256<short> shift);
        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, Vector256<int> shift);
        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, Vector256<long> shift);
        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, const byte shift);
        public static Vector256<byte> RotateRight(Vector256<byte> value, const byte shift);
        public static Vector256<short> RotateRight(Vector256<short> value, const byte shift);
        public static Vector256<ushort> RotateRight(Vector256<ushort> value, const byte shift);
        public static Vector256<int> RotateRight(Vector256<int> value, const byte shift);
        public static Vector256<uint> RotateRight(Vector256<uint> value, const byte shift);
        public static Vector256<long> RotateRight(Vector256<long> value, const byte shift);
        public static Vector256<ulong> RotateRight(Vector256<ulong> value, const byte shift);
        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, Vector256<sbyte> shift);
        public static Vector256<byte> RotateRight(Vector256<byte> value, Vector256<byte> shift);
        public static Vector256<short> RotateRight(Vector256<short> value, Vector256<short> shift);
        public static Vector256<ushort> RotateRight(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector256<int> RotateRight(Vector256<int> value, Vector256<int> shift);
        public static Vector256<uint> RotateRight(Vector256<uint> value, Vector256<uint> shift);
        public static Vector256<long> RotateRight(Vector256<long> value, Vector256<long> shift);
        public static Vector256<ulong> RotateRight(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<byte> Abs(Vector256<sbyte> value);
        public static Vector256<ushort> Abs(Vector256<short> value);
        public static Vector256<uint> Abs(Vector256<int> value);
        public static Vector256<ulong> Abs(Vector256<long> value);
        public static Vector256<float> Abs(Vector256<float> value);
        public static Vector256<double> Abs(Vector256<double> value);
        public static Vector256<float> Floor(Vector256<float> value);
        public static Vector256<double> Floor(Vector256<double> value);
        public static Vector256<float> Ceiling(Vector256<float> value);
        public static Vector256<double> Ceiling(Vector256<double> value);
        public static Vector256<float> RoundToZero(Vector256<float> value);
        public static Vector256<double> RoundToZero(Vector256<double> value);
        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value);
        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value);
        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value);
        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> 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);
        // /// <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);
        // /// <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);
        // /// <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);
        public static Vector256<int> Insert(Vector256<int> vector, int data, const byte index);
        public static Vector256<uint> Insert(Vector256<uint> vector, uint data, const byte index);
        public static Vector256<long> Insert(Vector256<long> vector, long data, const byte index);
        public static Vector256<ulong> Insert(Vector256<ulong> vector, ulong data, const byte index);
        public static Vector256<float> Insert(Vector256<float> vector, float data, const byte index);
        public static Vector256<double> Insert(Vector256<double> vector, double data, const byte index);
        public static Vector256<sbyte> DuplicateToVector256(sbyte value);
        public static Vector256<byte> DuplicateToVector256(byte value);
        public static Vector256<short> DuplicateToVector256(short value);
        public static Vector256<ushort> DuplicateToVector256(ushort value);
        public static Vector256<int> DuplicateToVector256(int value);
        public static Vector256<uint> DuplicateToVector256(uint value);
        public static Vector256<long> DuplicateToVector256(long value);
        public static Vector256<ulong> DuplicateToVector256(ulong value);
        public static Vector256<float> DuplicateToVector256(float value);
        public static Vector256<double> DuplicateToVector256(double value);
        public static Vector256<float> ConvertToSingle(Vector256<int> value);
        public static Vector256<float> ConvertToSingle(Vector256<uint> value);
        public static Vector256<double> ConvertToDouble(Vector256<long> value);
        public static Vector256<double> ConvertToDouble(Vector256<ulong> value);
        public static bool HasElementsNotZero(Vector256<byte> value);
        public static bool AllElementsIsZero(Vector256<byte> value);
        public static bool AllElementsNotZero(Vector256<sbyte> value);
        public static bool AllElementsNotZero(Vector256<byte> value);
        public static bool AllElementsNotZero(Vector256<short> value);
        public static bool AllElementsNotZero(Vector256<ushort> value);
        public static bool AllElementsNotZero(Vector256<int> value);
        public static bool AllElementsNotZero(Vector256<uint> value);
        public static bool AllElementsNotZero(Vector256<long> value);
        public static bool AllElementsNotZero(Vector256<ulong> value);
        public static bool HasElementsIsZero(Vector256<sbyte> value);
        public static bool HasElementsIsZero(Vector256<byte> value);
        public static bool HasElementsIsZero(Vector256<short> value);
        public static bool HasElementsIsZero(Vector256<ushort> value);
        public static bool HasElementsIsZero(Vector256<int> value);
        public static bool HasElementsIsZero(Vector256<uint> value);
        public static bool HasElementsIsZero(Vector256<long> value);
        public static bool HasElementsIsZero(Vector256<ulong> value);
        public static Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, byte shift);
        public static Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, byte shift);
        public static Vector256<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, byte shift);
        public static Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, byte shift);
        public static Vector256<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, byte shift);
        public static Vector256<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, byte 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);
        public static Vector128<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvssrlni_d_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRLNI.D.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x4_t xvssrlni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
        /////   LASX: XVSSRLNI.DU.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvssran_d_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRANI.D.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector256<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x4_t xvssrani_du_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRANI.DU.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvssrlrni_d_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRLRNI.D.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x4_t xvssrlrni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
        /////   LASX: XVSSRLRNI.DU.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift);
        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift);
        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift);
        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// int64x4_t xvssrarn_d_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRARNI.D.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector256<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift);
        public static Vector256<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift);
        public static Vector256<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift);
        ///// <summary>
        ///// uint64x4_t xvssrarni_du_q(int128x2_t left, int128x2_t right, const byte n)
        /////   LASX: XVSSRARNI.DU.Q Xd.4D, Xj.2Q, ui7
        ///// </summary>
        //public static Vector256<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift);
        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift);
        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift);
        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift);
        public static Vector256<sbyte> LeadingSignCount(Vector256<sbyte> value);
        public static Vector256<short> LeadingSignCount(Vector256<short> value);
        public static Vector256<int> LeadingSignCount(Vector256<int> value);
        public static Vector256<long> LeadingSignCount(Vector256<long> value);
        public static Vector256<sbyte> LeadingZeroCount(Vector256<sbyte> value);
        public static Vector256<byte> LeadingZeroCount(Vector256<byte> value);
        public static Vector256<short> LeadingZeroCount(Vector256<short> value);
        public static Vector256<ushort> LeadingZeroCount(Vector256<ushort> value);
        public static Vector256<int> LeadingZeroCount(Vector256<int> value);
        public static Vector256<uint> LeadingZeroCount(Vector256<uint> value);
        public static Vector256<long> LeadingZeroCount(Vector256<long> value);
        public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value);
        public static Vector256<sbyte> PopCount(Vector256<sbyte> value);
        public static Vector256<byte> PopCount(Vector256<byte> value);
        public static Vector256<short> PopCount(Vector256<short> value);
        public static Vector256<ushort> PopCount(Vector256<ushort> value);
        public static Vector256<int> PopCount(Vector256<int> value);
        public static Vector256<uint> PopCount(Vector256<uint> value);
        public static Vector256<long> PopCount(Vector256<long> value);
        public static Vector256<ulong> PopCount(Vector256<ulong> value);
        public static Vector256<int> VectorShuffle(Vector256<int> vector, Vector256<int> indexs);
        public static Vector256<uint> VectorShuffle(Vector256<uint> vector, Vector256<uint> indexs);
        public static Vector256<long> VectorShuffle(Vector256<long> vector, const byte indexs);
        public static Vector256<ulong> VectorShuffle(Vector256<ulong> vector, const byte indexs);
        public static Vector256<long> VectorShuffle(Vector256<long> vector0, Vector256<long> vector1, const byte 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);
        ///// <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);
        public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector0, Vector256<byte> vector1, Vector256<byte> indexs);
        public static Vector256<sbyte> VectorShuffleEach128(Vector256<sbyte> vector0, Vector256<sbyte> vector1, Vector256<sbyte> 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);
        ///// <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);
        public static Vector256<short> VectorShuffleEach128(Vector256<short> vector0, Vector256<short> vector1, Vector256<short> indexs);
        public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector0, Vector256<ushort> vector1, Vector256<ushort> indexs);
        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector, const byte indexs);
        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector, const byte indexs);
        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector0, Vector256<int> vector1, Vector256<int> indexs);
        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector0, Vector256<uint> vector1, Vector256<uint> indexs);
        public static Vector256<long> VectorShuffleEach128(Vector256<long> vector0, Vector256<long> vector1, Vector256<long> indexs);
        public static Vector256<ulong> VectorShuffleEach128(Vector256<ulong> vector0, Vector256<ulong> vector1, Vector256<ulong> indexs);
        public static Vector256<sbyte> VectorShuffleBy4Elements(Vector256<sbyte> vector, byte indexs);
        public static Vector256<byte> VectorShuffleBy4Elements(Vector256<byte> vector, byte indexs);
        public static Vector256<short> VectorShuffleBy4Elements(Vector256<short> vector, byte indexs);
        public static Vector256<ushort> VectorShuffleBy4Elements(Vector256<ushort> vector, byte indexs);
        public static Vector256<int> VectorShuffleBy4Elements(Vector256<int> vector, byte indexs);
        public static Vector256<uint> VectorShuffleBy4Elements(Vector256<uint> vector, byte indexs);
        public static Vector256<long> VectorShuffleBy4Elements(Vector256<long> vector0, Vector256<long> vector1, byte indexs);
        public static Vector256<ulong> VectorShuffleBy4Elements(Vector256<ulong> vector0, Vector256<ulong> vector1, byte indexs);
        public static Vector256<sbyte> VectorElementsFusionLowerEach128(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorElementsFusionLowerEach128(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorElementsFusionLowerEach128(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorElementsFusionLowerEach128(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorElementsFusionLowerEach128(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorElementsFusionLowerEach128(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorElementsFusionLowerEach128(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorElementsFusionLowerEach128(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> VectorElementsFusionHightEach128(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorElementsFusionHightEach128(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorElementsFusionHightEach128(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorElementsFusionHightEach128(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorElementsFusionHightEach128(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorElementsFusionHightEach128(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorElementsFusionHightEach128(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorElementsFusionHightEach128(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> VectorElementsFusionEven(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorElementsFusionEven(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorElementsFusionEven(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorElementsFusionEven(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorElementsFusionEven(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorElementsFusionEven(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorElementsFusionEven(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorElementsFusionEven(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> VectorElementsFusionOdd(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorElementsFusionOdd(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorElementsFusionOdd(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorElementsFusionOdd(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorElementsFusionOdd(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorElementsFusionOdd(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorElementsFusionOdd(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorElementsFusionOdd(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> VectorEvenElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorEvenElementsJoinEach128(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorEvenElementsJoinEach128(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorEvenElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorEvenElementsJoinEach128(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorEvenElementsJoinEach128(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorEvenElementsJoinEach128(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorEvenElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<sbyte> VectorOddElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right);
        public static Vector256<byte> VectorOddElementsJoinEach128(Vector256<byte> left, Vector256<byte> right);
        public static Vector256<short> VectorOddElementsJoinEach128(Vector256<short> left, Vector256<short> right);
        public static Vector256<ushort> VectorOddElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right);
        public static Vector256<int> VectorOddElementsJoinEach128(Vector256<int> left, Vector256<int> right);
        public static Vector256<uint> VectorOddElementsJoinEach128(Vector256<uint> left, Vector256<uint> right);
        public static Vector256<long> VectorOddElementsJoinEach128(Vector256<long> left, Vector256<long> right);
        public static Vector256<ulong> VectorOddElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right);
        public static Vector256<byte> VectorElementReplicateEach128(Vector256<byte> vector, const byte elementIndexe);
        public static Vector256<sbyte> VectorElementReplicateEach128(Vector256<sbyte> vector, const byte elementIndexe);
        public static Vector256<short> VectorElementReplicateEach128(Vector256<short> vector, const byte elementIndexe);
        public static Vector256<ushort> VectorElementReplicateEach128(Vector256<ushort> vector, const byte elementIndexe);
        public static Vector256<int> VectorElementReplicateEach128(Vector256<int> vector, const byte elementIndexe);
        public static Vector256<uint> VectorElementReplicateEach128(Vector256<uint> vector, const byte elementIndexe);
        public static Vector256<long> VectorElementReplicateEach128(Vector256<long> vector, const byte elementIndexe);
        public static Vector256<ulong> VectorElementReplicateEach128(Vector256<ulong> vector, const byte elementIndexe);
        public static Vector258<sbyte> UpdateOneVectorElementEach128(Vector258<sbyte> vector, const byte indexs);
        public static Vector258<byte> UpdateOneVectorElementEach128(Vector258<byte> vector, const byte indexs);
        public static Vector258<short> UpdateOneVectorElementEach128(Vector258<short> vector, const byte indexs);
        public static Vector258<ushort> UpdateOneVectorElementEach128(Vector258<ushort> vector, const byte indexs);
        public static Vector258<int> UpdateOneVectorElementEach128(Vector258<int> vector, const byte indexs);
        public static Vector258<uint> UpdateOneVectorElementEach128(Vector258<uint> vector, const byte indexs);
        public static Vector258<long> UpdateOneVectorElementEach128(Vector258<long> vector, const byte indexs);
        public static Vector258<ulong> UpdateOneVectorElementEach128(Vector258<ulong> vector, const byte indexs);
        public static Vector258<sbyte> VectorElementNegatedBySign(Vector258<sbyte> sign, Vector258<sbyte> data);
        public static Vector258<short> VectorElementNegatedBySign(Vector258<short> sign, Vector258<short> data);
        public static Vector258<int> VectorElementNegatedBySign(Vector258<int> sign, Vector258<int> data);
        public static Vector258<long> VectorElementNegatedBySign(Vector258<long> sign, Vector258<long> data);
        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, const byte index);
        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, const byte index);
        public static Vector256<short> VectorElementBitClear(Vector256<short> value, const byte index);
        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, const byte index);
        public static Vector256<int> VectorElementBitClear(Vector256<int> value, const byte index);
        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, const byte index);
        public static Vector256<long> VectorElementBitClear(Vector256<long> value, const byte index);
        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, const byte index);
        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, Vector256<sbyte> index);
        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, Vector256<byte> index);
        public static Vector256<short> VectorElementBitClear(Vector256<short> value, Vector256<short> index);
        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, Vector256<ushort> index);
        public static Vector256<int> VectorElementBitClear(Vector256<int> value, Vector256<int> index);
        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, Vector256<uint> index);
        public static Vector256<long> VectorElementBitClear(Vector256<long> value, Vector256<long> index);
        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, Vector256<ulong> index);
        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, const byte index);
        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, const byte index);
        public static Vector256<short> VectorElementBitSet(Vector256<short> value, const byte index);
        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, const byte index);
        public static Vector256<int> VectorElementBitSet(Vector256<int> value, const byte index);
        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, const byte index);
        public static Vector256<long> VectorElementBitSet(Vector256<long> value, const byte index);
        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, const byte index);
        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, Vector256<sbyte> index);
        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, Vector256<byte> index);
        public static Vector256<short> VectorElementBitSet(Vector256<short> value, Vector256<short> index);
        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, Vector256<ushort> index);
        public static Vector256<int> VectorElementBitSet(Vector256<int> value, Vector256<int> index);
        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, Vector256<uint> index);
        public static Vector256<long> VectorElementBitSet(Vector256<long> value, Vector256<long> index);
        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, Vector256<ulong> index);
        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, const byte index);
        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, const byte index);
        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, const byte index);
        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, const byte index);
        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, const byte index);
        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, const byte index);
        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, const byte index);
        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, const byte index);
        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, Vector256<sbyte> index);
        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, Vector256<byte> index);
        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, Vector256<short> index);
        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, Vector256<ushort> index);
        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, Vector256<int> index);
        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, Vector256<uint> index);
        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, Vector256<long> index);
        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index);
        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, Vector256<sbyte> save);
        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, Vector256<short> save);
        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, const byte save);
        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, const byte save);
        public static Vector256<sbyte> VectorSaturate(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits);
        public static Vector256<short> VectorSaturate(Vector256<short> value, [ConstantExpected(Max = (byte)(15))] byte bits);
        public static Vector256<int> VectorSaturate(Vector256<int> value, [ConstantExpected(Max = (byte)(31))] byte bits);
        public static Vector256<long> VectorSaturate(Vector256<long> value, [ConstantExpected(Max = (byte)(63))] byte bits);
        public static Vector256<byte> VectorSaturateUnsigned(Vector256<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits);
        public static Vector256<ushort> VectorSaturateUnsigned(Vector256<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits);
        public static Vector256<uint> VectorSaturateUnsigned(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits);
        public static Vector256<ulong> VectorSaturateUnsigned(Vector256<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits);
        public static Vector256<int> FloatClass(Vector256<float> value);
        public static Vector256<long> FloatClass(Vector256<double> value);
    }

@shushanhf
Copy link
Contributor Author

Where is the spec for the LA64 SIMD ISA?

Based on https://loongson.github.io/LoongArch-Documentation/README-EN.html, it looks like it should be Volume 2, but there doesn't appear to be any version published for it yet and the backing GitHub repo looks to be archived now and I do not see a replacement.

Hi, @tannergooding

The GCC had merged the LoongArch's SIMD feature.
https://github.com/gcc-mirror/gcc/blob/master/gcc/config/loongarch/lsxintrin.h
https://github.com/gcc-mirror/gcc/blob/master/gcc/config/loongarch/lasxintrin.h

And the LLVM is same.

There is an unofficial LoongArch SIMD-intrinsics manual:
https://github.com/jiegec/unofficial-loongarch-intrinsics-guide?tab=readme-ov-file
https://jia.je/unofficial-loongarch-intrinsics-guide/

BTW, maybe we can review the API interfaces by different types, for example, the add/sub/multiple/div/or/and/max/min are the basal and common part of the SIMD feature.
Is it OK by this way ?

@tannergooding tannergooding added needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration and removed untriaged New issue has not been triaged by the area owner labels Jun 24, 2024
@stephentoub stephentoub added this to the Future milestone Jul 19, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
api-suggestion Early API idea and discussion, it is NOT ready for implementation area-System.Runtime.Intrinsics needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration
Projects
None yet
Milestone
Future
Development

No branches or pull requests
4 participants
@stephentoub @huoyaoyuan @tannergooding @shushanhf