ICS-SCADA-APP-WEN/Library/PackageCache/com.unity.burst/Runtime/Intrinsics/x86/Sse4_2.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Unity.Burst.Intrinsics
{
    public unsafe static partial class X86
    {
        /// <summary>
        /// SSE 4.2 intrinsics
        /// </summary>
        public static class Sse4_2
        {
            /// <summary>
            /// Evaluates to true at compile time if SSE 4.2 intrinsics are supported.
            /// </summary>
            public static bool IsSse42Supported { get { return false; } }

            /// <summary>
            /// Constants for string comparison intrinsics
            /// </summary>
            [Flags]
            public enum SIDD
            {
                /// <summary>
                /// Compare 8-bit unsigned characters
                /// </summary>
                UBYTE_OPS = 0x00,
                /// <summary>
                /// Compare 16-bit unsigned characters
                /// </summary>
                UWORD_OPS = 0x01,
                /// <summary>
                /// Compare 8-bit signed characters
                /// </summary>
                SBYTE_OPS = 0x02,
                /// <summary>
                /// Compare 16-bit signed characters
                /// </summary>
                SWORD_OPS = 0x03,

                /// <summary>
                /// Compare any equal
                /// </summary>
                CMP_EQUAL_ANY = 0x00,
                /// <summary>
                /// Compare ranges
                /// </summary>
                CMP_RANGES = 0x04,
                /// <summary>
                /// Compare equal each
                /// </summary>
                CMP_EQUAL_EACH = 0x08,
                /// <summary>
                /// Compare equal ordered
                /// </summary>
                CMP_EQUAL_ORDERED = 0x0C,

                /// <summary>
                /// Normal result polarity
                /// </summary>
                POSITIVE_POLARITY = 0x00,
                /// <summary>
                /// Negate results
                /// </summary>
                NEGATIVE_POLARITY = 0x10,
                /// <summary>
                /// Normal results only before end of string
                /// </summary>
                MASKED_POSITIVE_POLARITY = 0x20,
                /// <summary>
                /// Negate results only before end of string
                /// </summary>
                MASKED_NEGATIVE_POLARITY = 0x30,

                /// <summary>
                /// Index only: return least significant bit
                /// </summary>
                LEAST_SIGNIFICANT = 0x00,
                /// <summary>
                /// Index only: return most significan bit
                /// </summary>
                MOST_SIGNIFICANT = 0x40,

                /// <summary>
                /// mask only: return bit mask
                /// </summary>
                BIT_MASK = 0x00,
                /// <summary>
                /// mask only: return byte/word mask
                /// </summary>
                UNIT_MASK = 0x40,

            }

            /*
             * Intrinsics for text/string processing.
             */

            private unsafe struct StrBoolArray
            {
                public fixed ushort Bits[16];

                public void SetBit(int aindex, int bindex, bool val)
                {
                    fixed (ushort* b = Bits)
                    {
                        if (val)
                            b[aindex] |= (ushort)(1 << bindex);
                        else
                            b[aindex] &= (ushort)(~(1 << bindex));
                    }
                }

                public bool GetBit(int aindex, int bindex)
                {
                    fixed (ushort* b = Bits)
                    {
                        return (b[aindex] & (1 << bindex)) != 0;
                    }
                }
            }

            private static v128 cmpistrm_emulation<T>(T* a, T* b, int len, int imm8, int allOnes, T allOnesT) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
                int intRes2 = ComputeStrCmpIntRes2<T>(a, ComputeStringLength<T>(a, len), b, ComputeStringLength<T>(b, len), len, imm8, allOnes);

                return ComputeStrmOutput(len, imm8, allOnesT, intRes2);
            }

            private static v128 cmpestrm_emulation<T>(T* a, int alen, T* b, int blen, int len, int imm8, int allOnes, T allOnesT) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
                int intRes2 = ComputeStrCmpIntRes2<T>(a, alen, b, blen, len, imm8, allOnes);

                return ComputeStrmOutput(len, imm8, allOnesT, intRes2);
            }

            private static v128 ComputeStrmOutput<T>(int len, int imm8, T allOnesT, int intRes2) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
                // output
                v128 result = default;
                if ((imm8 & (1 << 6)) != 0)
                {
                    // byte / word mask
                    T* maskDst = (T*)&result.Byte0;
                    for (int i = 0; i < len; ++i)
                    {
                        if ((intRes2 & (1 << i)) != 0)
                        {
                            maskDst[i] = allOnesT;
                        }
                        else
                        {
                            maskDst[i] = default(T);
                        }
                    }
                }
                else
                {
                    // bit mask
                    result.SInt0 = intRes2;
                }

                return result;
            }

            private static int cmpistri_emulation<T>(T* a, T* b, int len, int imm8, int allOnes, T allOnesT) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
                int intRes2 = ComputeStrCmpIntRes2<T>(a, ComputeStringLength<T>(a, len), b, ComputeStringLength<T>(b, len), len, imm8, allOnes);

                return ComputeStriOutput(len, imm8, intRes2);
            }

            private static int cmpestri_emulation<T>(T* a, int alen, T* b, int blen, int len, int imm8, int allOnes, T allOnesT) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
                int intRes2 = ComputeStrCmpIntRes2<T>(a, alen, b, blen, len, imm8, allOnes);

                return ComputeStriOutput(len, imm8, intRes2);
            }

            private static int ComputeStriOutput(int len, int imm8, int intRes2)
            {
                // output
                if ((imm8 & (1 << 6)) == 0)
                {
                    int bit = 0;
                    while (bit < len)
                    {
                        if ((intRes2 & (1 << bit)) != 0)
                            return bit;
                        ++bit;
                    }
                }
                else
                {
                    int bit = len - 1;
                    while (bit >= 0)
                    {
                        if ((intRes2 & (1 << bit)) != 0)
                            return bit;
                        --bit;
                    }
                }

                return len;
            }

            private static int ComputeStringLength<T>(T* ptr, int max) where T : unmanaged, IEquatable<T>
            {
                for (int i = 0; i < max; ++i)
                {
                    if (EqualityComparer<T>.Default.Equals(ptr[i], default(T)))
                    {
                        return i;
                    }
                }
                return max;
            }

            private static int ComputeStrCmpIntRes2<T>(T* a, int alen, T* b, int blen, int len, int imm8, int allOnes) where T : unmanaged, IComparable<T>, IEquatable<T>
            {
#if !NET_DOTS
                bool aInvalid = false;
                bool bInvalid = false;
                StrBoolArray boolRes = default;
                int i, j, intRes2;

                for (i = 0; i < len; ++i)
                {
                    T aCh = a[i];

                    if (i == alen)
                        aInvalid = true;

                    bInvalid = false;
                    for (j = 0; j < len; ++j)
                    {
                        T bCh = b[j];
                        if (j == blen)
                            bInvalid = true;

                        bool match;

                        // override comparisons for invalid characters
                        switch ((imm8 >> 2) & 3)
                        {
                            case 0:  // equal any
                                match = EqualityComparer<T>.Default.Equals(aCh, bCh);
                                if (!aInvalid && bInvalid)
                                    match = false;
                                else if (aInvalid && !bInvalid)
                                    match = false;
                                else if (aInvalid && bInvalid)
                                    match = false;
                                break;

                            case 1:  // ranges
                                if (0 == (i & 1))
                                    match = Comparer<T>.Default.Compare(bCh, aCh) >= 0;
                                else
                                    match = Comparer<T>.Default.Compare(bCh, aCh) <= 0;

                                if (!aInvalid && bInvalid)
                                    match = false;
                                else if (aInvalid && !bInvalid)
                                    match = false;
                                else if (aInvalid && bInvalid)
                                    match = false;
                                break;
                            case 2:  // equal each
                                match = EqualityComparer<T>.Default.Equals(aCh, bCh);
                                if (!aInvalid && bInvalid)
                                    match = false;
                                else if (aInvalid && !bInvalid)
                                    match = false;
                                else if (aInvalid && bInvalid)
                                    match = true;
                                break;
                            default:  // equal ordered
                                match = EqualityComparer<T>.Default.Equals(aCh, bCh);
                                if (!aInvalid && bInvalid)
                                    match = false;
                                else if (aInvalid && !bInvalid)
                                    match = true;
                                else if (aInvalid && bInvalid)
                                    match = true;
                                break;
                        }

                        boolRes.SetBit(i, j, match);
                    }
                }

                int intRes1 = 0;

                // aggregate results
                switch ((imm8 >> 2) & 3)
                {
                    case 0:  // equal any
                        for (i = 0; i < len; ++i)
                        {
                            for (j = 0; j < len; ++j)
                            {
                                intRes1 |= (boolRes.GetBit(j, i) ? 1 : 0) << i;
                            }
                        }
                        /*
                        for (i = 0; i < len; ++i)
                        {
                            intRes1 |= boolRes.Bits[i];
                        }*/
                        break;
                    case 1:  // ranges
                        for (i = 0; i < len; ++i)
                        {
                            for (j = 0; j < len; j += 2)
                            {
                                intRes1 |= ((boolRes.GetBit(j, i) && boolRes.GetBit(j + 1, i)) ? 1 : 0) << i;
                            }
                        }
                        break;
                    case 2:  // equal each
                        for (i = 0; i < len; ++i)
                        {
                            intRes1 |= (boolRes.GetBit(i, i) ? 1 : 0) << i;
                        }
                        break;
                    case 3:  // equal ordered
                        intRes1 = allOnes;
                        for (i = 0; i < len; ++i)
                        {
                            int k = i;
                            for (j = 0; j < len - i; ++j)
                            {
                                if (!boolRes.GetBit(j, k))
                                    intRes1 &= ~(1 << i);
                                k += 1;
                            }
                        }
                        break;
                }

                intRes2 = 0;

                // optionally negate results
                bInvalid = false;
                for (i = 0; i < len; ++i)
                {
                    if ((imm8 & (1 << 4)) != 0)
                    {
                        if ((imm8 & (1 << 5)) != 0) // only negate valid
                        {
                            if (EqualityComparer<T>.Default.Equals(b[i], default(T)))
                            {
                                bInvalid = true;
                            }

                            if (bInvalid) // invalid, don't negate
                                intRes2 |= intRes1 & (1 << i);
                            else // valid, negate
                                intRes2 |= (~intRes1) & (1 << i);
                        }
                        else // negate all
                            intRes2 |= (~intRes1) & (1 << i);
                    }
                    else // don't negate
                        intRes2 |= intRes1 & (1 << i);
                }

                return intRes2;
#else
                throw new NotImplementedException("dots runtime C# lacks comparer");
#endif
            }

            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and store the generated mask in dst.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Vector</returns>
            [DebuggerStepThrough]
            public static v128 cmpistrm(v128 a, v128 b, int imm8)
            {
                v128 c;

                if (0 == (imm8 & 1))
                    if (0 == (imm8 & 2))
                        c = cmpistrm_emulation(&a.Byte0, &b.Byte0, 16, imm8, 0xffff, (byte)0xff);
                    else
                        c = cmpistrm_emulation(&a.SByte0, &b.SByte0, 16, imm8, 0xffff, (sbyte)-1);
                else
                    if (0 == (imm8 & 2))
                    c = cmpistrm_emulation(&a.UShort0, &b.UShort0, 8, imm8, 0xff, (ushort)0xffff);
                else
                    c = cmpistrm_emulation(&a.SShort0, &b.SShort0, 8, imm8, 0xff, (short)-1);

                return c;
            }


            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and store the generated index in dst.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Index</returns>
            [DebuggerStepThrough]
            public static int cmpistri(v128 a, v128 b, int imm8)
            {
                if (0 == (imm8 & 1))
                    if (0 == (imm8 & 2))
                        return cmpistri_emulation(&a.Byte0, &b.Byte0, 16, imm8, 0xffff, (byte)0xff);
                    else
                        return cmpistri_emulation(&a.SByte0, &b.SByte0, 16, imm8, 0xffff, (sbyte)-1);
                else
                    if (0 == (imm8 & 2))
                    return cmpistri_emulation(&a.UShort0, &b.UShort0, 8, imm8, 0xff, (ushort)0xffff);
                else
                    return cmpistri_emulation(&a.SShort0, &b.SShort0, 8, imm8, 0xff, (short)-1);
            }

            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and store the generated mask in dst.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Vector</returns>
            [DebuggerStepThrough]
            public static v128 cmpestrm(v128 a, int la, v128 b, int lb, int imm8)
            {
                v128 c;

                if (0 == (imm8 & 1))
                    if (0 == (imm8 & 2))
                        c = cmpestrm_emulation(&a.Byte0, la, &b.Byte0, lb, 16, imm8, 0xffff, (byte)0xff);
                    else
                        c = cmpestrm_emulation(&a.SByte0, la, &b.SByte0, lb, 16, imm8, 0xffff, (sbyte)-1);
                else
                    if (0 == (imm8 & 2))
                    c = cmpestrm_emulation(&a.UShort0, la, &b.UShort0, lb, 8, imm8, 0xff, (ushort)0xffff);
                else
                    c = cmpestrm_emulation(&a.SShort0, la, &b.SShort0, lb, 8, imm8, 0xff, (short)-1);

                return c;
            }

            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and store the generated index in dst.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Index</returns>
            [DebuggerStepThrough]
            public static int cmpestri(v128 a, int la, v128 b, int lb, int imm8)
            {
                if (0 == (imm8 & 1))
                    if (0 == (imm8 & 2))
                        return cmpestri_emulation(&a.Byte0, la, &b.Byte0, lb, 16, imm8, 0xffff, (byte)0xff);
                    else
                        return cmpestri_emulation(&a.SByte0, la, &b.SByte0, lb, 16, imm8, 0xffff, (sbyte)-1);
                else
                    if (0 == (imm8 & 2))
                    return cmpestri_emulation(&a.UShort0, la, &b.UShort0, lb, 8, imm8, 0xff, (ushort)0xffff);
                else
                    return cmpestri_emulation(&a.SShort0, la, &b.SShort0, lb, 8, imm8, 0xff, (short)-1);
            }

            /*
             * Intrinsics for text/string processing and reading values of EFlags.
             */

            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if any character in b was null, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpistrz(v128 a, v128 b, int imm8)
            {
                if (0 == (imm8 & 1))
                    return ComputeStringLength<byte>(&b.Byte0, 16) < 16 ? 1 : 0;
                else
                    return ComputeStringLength<ushort>(&b.UShort0, 8) < 8 ? 1 : 0;
            }


            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpistrc(v128 a, v128 b, int imm8)
            {
                v128 q = cmpistrm(a, b, imm8);
                return q.SInt0 == 0 && q.SInt1 == 0 && q.SInt2 == 0 && q.SInt3 == 0 ? 0 : 1;
            }
            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if any character in a was null, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpistrs(v128 a, v128 b, int imm8)
            {
                if (0 == (imm8 & 1))
                    return ComputeStringLength<byte>(&a.Byte0, 16) < 16 ? 1 : 0;
                else
                    return ComputeStringLength<ushort>(&a.UShort0, 8) < 8 ? 1 : 0;
            }

            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and returns bit 0 of the resulting bit mask.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Bit 0</returns>
            [DebuggerStepThrough]
            public static int cmpistro(v128 a, v128 b, int imm8)
            {
                int intRes2;

                if (0 == (imm8 & 1))
                {
                    int al = ComputeStringLength<byte>(&a.Byte0, 16);
                    int bl = ComputeStringLength<byte>(&b.Byte0, 16);

                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<byte>(&a.Byte0, al, &b.Byte0, bl, 16, imm8, 0xffff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<sbyte>(&a.SByte0, al, &b.SByte0, bl, 16, imm8, 0xffff);
                }
                else
                {
                    int al = ComputeStringLength<ushort>(&a.UShort0, 8);
                    int bl = ComputeStringLength<ushort>(&b.UShort0, 8);

                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<ushort>(&a.UShort0, al, &b.UShort0, bl, 8, imm8, 0xff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<short>(&a.SShort0, al, &b.SShort0, bl, 8, imm8, 0xff);
                }

                return intRes2 & 1;
            }

            /// <summary>
            /// Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if b did not contain a null character and the resulting mask was zero, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpistra(v128 a, v128 b, int imm8)
            {
                return ((~cmpistrc(a, b, imm8)) & (~cmpistrz(a, b, imm8))) & 1;
            }

            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if any character in b was null, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpestrz(v128 a, int la, v128 b, int lb, int imm8)
            {
                int size = (imm8 & 1) == 1 ? 16 : 8;
                int upperBound = (128 / size) - 1;
                return lb <= upperBound ? 1 : 0;
            }

            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpestrc(v128 a, int la, v128 b, int lb, int imm8)
            {
                int intRes2;

                if (0 == (imm8 & 1))
                {
                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<byte>(&a.Byte0, la, &b.Byte0, lb, 16, imm8, 0xffff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<sbyte>(&a.SByte0, la, &b.SByte0, lb, 16, imm8, 0xffff);
                }
                else
                {
                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<ushort>(&a.UShort0, la, &b.UShort0, lb, 8, imm8, 0xff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<short>(&a.SShort0, la, &b.SShort0, lb, 8, imm8, 0xff);
                }

                return intRes2 != 0 ? 1 : 0;
            }
            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if any character in a was null, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpestrs(v128 a, int la, v128 b, int lb, int imm8)
            {
                int size = (imm8 & 1) == 1 ? 16 : 8;
                int upperBound = (128 / size) - 1;
                return la <= upperBound ? 1 : 0;
            }

            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns bit 0 of the resulting bit mask.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Bit 0</returns>
            [DebuggerStepThrough]
            public static int cmpestro(v128 a, int la, v128 b, int lb, int imm8)
            {
                int intRes2;

                if (0 == (imm8 & 1))
                {
                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<byte>(&a.Byte0, la, &b.Byte0, lb, 16, imm8, 0xffff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<sbyte>(&a.SByte0, la, &b.SByte0, lb, 16, imm8, 0xffff);
                }
                else
                {
                    if (0 == (imm8 & 2))
                        intRes2 = ComputeStrCmpIntRes2<ushort>(&a.UShort0, la, &b.UShort0, lb, 8, imm8, 0xff);
                    else
                        intRes2 = ComputeStrCmpIntRes2<short>(&a.SShort0, la, &b.SShort0, lb, 8, imm8, 0xff);
                }

                return intRes2 & 1;
            }
            /// <summary>
            /// Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if b did not contain a null character and the resulting mask was zero, and 0 otherwise.
            /// </summary>
			/// <param name="a">Vector a</param>
			/// <param name="b">Vector b</param>
			/// <param name="la">Length a</param>
			/// <param name="lb">Length b</param>
			/// <param name="imm8">Control</param>
			/// <returns>Boolean value</returns>
            [DebuggerStepThrough]
            public static int cmpestra(v128 a, int la, v128 b, int lb, int imm8)
            {
                return ((~cmpestrc(a, la, b, lb, imm8)) & (~cmpestrz(a, la, b, lb, imm8))) & 1;
            }

            /// <summary>
            /// Compare packed 64-bit integers in a and b for greater-than, and store the results in dst.
            /// </summary>
			/// <param name="val1">Vector a</param>
			/// <param name="val2">Vector b</param>
			/// <returns>Vector</returns>
            [DebuggerStepThrough]
            public static v128 cmpgt_epi64(v128 val1, v128 val2)
            {
                v128 result = default;
                result.SLong0 = val1.SLong0 > val2.SLong0 ? -1 : 0;
                result.SLong1 = val1.SLong1 > val2.SLong1 ? -1 : 0;
                return result;
            }

            /*
             * Accumulate CRC32 (polynomial 0x11EDC6F41) value
             */

            private static readonly uint[] crctab = new uint[]
            {
                0x00000000U,0xF26B8303U,0xE13B70F7U,0x1350F3F4U,0xC79A971FU,0x35F1141CU,0x26A1E7E8U,0xD4CA64EBU,
                0x8AD958CFU,0x78B2DBCCU,0x6BE22838U,0x9989AB3BU,0x4D43CFD0U,0xBF284CD3U,0xAC78BF27U,0x5E133C24U,
                0x105EC76FU,0xE235446CU,0xF165B798U,0x030E349BU,0xD7C45070U,0x25AFD373U,0x36FF2087U,0xC494A384U,
                0x9A879FA0U,0x68EC1CA3U,0x7BBCEF57U,0x89D76C54U,0x5D1D08BFU,0xAF768BBCU,0xBC267848U,0x4E4DFB4BU,
                0x20BD8EDEU,0xD2D60DDDU,0xC186FE29U,0x33ED7D2AU,0xE72719C1U,0x154C9AC2U,0x061C6936U,0xF477EA35U,
                0xAA64D611U,0x580F5512U,0x4B5FA6E6U,0xB93425E5U,0x6DFE410EU,0x9F95C20DU,0x8CC531F9U,0x7EAEB2FAU,
                0x30E349B1U,0xC288CAB2U,0xD1D83946U,0x23B3BA45U,0xF779DEAEU,0x05125DADU,0x1642AE59U,0xE4292D5AU,
                0xBA3A117EU,0x4851927DU,0x5B016189U,0xA96AE28AU,0x7DA08661U,0x8FCB0562U,0x9C9BF696U,0x6EF07595U,
                0x417B1DBCU,0xB3109EBFU,0xA0406D4BU,0x522BEE48U,0x86E18AA3U,0x748A09A0U,0x67DAFA54U,0x95B17957U,
                0xCBA24573U,0x39C9C670U,0x2A993584U,0xD8F2B687U,0x0C38D26CU,0xFE53516FU,0xED03A29BU,0x1F682198U,
                0x5125DAD3U,0xA34E59D0U,0xB01EAA24U,0x42752927U,0x96BF4DCCU,0x64D4CECFU,0x77843D3BU,0x85EFBE38U,
                0xDBFC821CU,0x2997011FU,0x3AC7F2EBU,0xC8AC71E8U,0x1C661503U,0xEE0D9600U,0xFD5D65F4U,0x0F36E6F7U,
                0x61C69362U,0x93AD1061U,0x80FDE395U,0x72966096U,0xA65C047DU,0x5437877EU,0x4767748AU,0xB50CF789U,
                0xEB1FCBADU,0x197448AEU,0x0A24BB5AU,0xF84F3859U,0x2C855CB2U,0xDEEEDFB1U,0xCDBE2C45U,0x3FD5AF46U,
                0x7198540DU,0x83F3D70EU,0x90A324FAU,0x62C8A7F9U,0xB602C312U,0x44694011U,0x5739B3E5U,0xA55230E6U,
                0xFB410CC2U,0x092A8FC1U,0x1A7A7C35U,0xE811FF36U,0x3CDB9BDDU,0xCEB018DEU,0xDDE0EB2AU,0x2F8B6829U,
                0x82F63B78U,0x709DB87BU,0x63CD4B8FU,0x91A6C88CU,0x456CAC67U,0xB7072F64U,0xA457DC90U,0x563C5F93U,
                0x082F63B7U,0xFA44E0B4U,0xE9141340U,0x1B7F9043U,0xCFB5F4A8U,0x3DDE77ABU,0x2E8E845FU,0xDCE5075CU,
                0x92A8FC17U,0x60C37F14U,0x73938CE0U,0x81F80FE3U,0x55326B08U,0xA759E80BU,0xB4091BFFU,0x466298FCU,
                0x1871A4D8U,0xEA1A27DBU,0xF94AD42FU,0x0B21572CU,0xDFEB33C7U,0x2D80B0C4U,0x3ED04330U,0xCCBBC033U,
                0xA24BB5A6U,0x502036A5U,0x4370C551U,0xB11B4652U,0x65D122B9U,0x97BAA1BAU,0x84EA524EU,0x7681D14DU,
                0x2892ED69U,0xDAF96E6AU,0xC9A99D9EU,0x3BC21E9DU,0xEF087A76U,0x1D63F975U,0x0E330A81U,0xFC588982U,
                0xB21572C9U,0x407EF1CAU,0x532E023EU,0xA145813DU,0x758FE5D6U,0x87E466D5U,0x94B49521U,0x66DF1622U,
                0x38CC2A06U,0xCAA7A905U,0xD9F75AF1U,0x2B9CD9F2U,0xFF56BD19U,0x0D3D3E1AU,0x1E6DCDEEU,0xEC064EEDU,
                0xC38D26C4U,0x31E6A5C7U,0x22B65633U,0xD0DDD530U,0x0417B1DBU,0xF67C32D8U,0xE52CC12CU,0x1747422FU,
                0x49547E0BU,0xBB3FFD08U,0xA86F0EFCU,0x5A048DFFU,0x8ECEE914U,0x7CA56A17U,0x6FF599E3U,0x9D9E1AE0U,
                0xD3D3E1ABU,0x21B862A8U,0x32E8915CU,0xC083125FU,0x144976B4U,0xE622F5B7U,0xF5720643U,0x07198540U,
                0x590AB964U,0xAB613A67U,0xB831C993U,0x4A5A4A90U,0x9E902E7BU,0x6CFBAD78U,0x7FAB5E8CU,0x8DC0DD8FU,
                0xE330A81AU,0x115B2B19U,0x020BD8EDU,0xF0605BEEU,0x24AA3F05U,0xD6C1BC06U,0xC5914FF2U,0x37FACCF1U,
                0x69E9F0D5U,0x9B8273D6U,0x88D28022U,0x7AB90321U,0xAE7367CAU,0x5C18E4C9U,0x4F48173DU,0xBD23943EU,
                0xF36E6F75U,0x0105EC76U,0x12551F82U,0xE03E9C81U,0x34F4F86AU,0xC69F7B69U,0xD5CF889DU,0x27A40B9EU,
                0x79B737BAU,0x8BDCB4B9U,0x988C474DU,0x6AE7C44EU,0xBE2DA0A5U,0x4C4623A6U,0x5F16D052U,0xAD7D5351U,
            };

            /// <summary>
            /// Starting with the initial value in crc, accumulates a CRC32 value for unsigned 32-bit integer v, and stores the result in dst.
            /// </summary>
			/// <param name="crc">Initial value</param>
			/// <param name="v">Unsigned 32-bit integer</param>
			/// <returns>Result</returns>
            [DebuggerStepThrough]
            public static uint crc32_u32(uint crc, uint v)
            {
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v);
                return crc;
            }

            /// <summary>
            /// Starting with the initial value in crc, accumulates a CRC32 value for unsigned 8-bit integer v, and stores the result in dst.
            /// </summary>
			/// <param name="crc">Initial value</param>
			/// <param name="v">Unsigned 8-bit integer</param>
			/// <returns>Result</returns>
            [DebuggerStepThrough]
            public static uint crc32_u8(uint crc, byte v)
            {
                crc = (crc >> 8) ^ crctab[(crc ^ v) & 0xff];
                return crc;
            }

            /// <summary>
            /// Starting with the initial value in crc, accumulates a CRC32 value for unsigned 16-bit integer v, and stores the result in dst.
            /// </summary>
			/// <param name="crc">Initial value</param>
			/// <param name="v">Unsigned 16-bit integer</param>
			/// <returns>Result</returns>
            [DebuggerStepThrough]
            public static uint crc32_u16(uint crc, ushort v)
            {
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v);
                return crc;
            }

            /// <summary>
            /// Starting with the initial value in crc, accumulates a CRC32 value for unsigned 64-bit integer v, and stores the result in dst.
            /// </summary>
			/// <param name="crc_ul">Initial value</param>
			/// <param name="v">Signed 64-bit integer</param>
			/// <returns>Result</returns>
            [DebuggerStepThrough]
            [Obsolete("Use the ulong version of this intrinsic instead.")]
            public static ulong crc32_u64(ulong crc_ul, long v)
            {
                return crc32_u64(crc_ul, (ulong)v);
            }

            /// <summary>
            /// Starting with the initial value in crc, accumulates a CRC32 value for unsigned 64-bit integer v, and stores the result in dst.
            /// </summary>
			/// <param name="crc_ul">Initial value</param>
			/// <param name="v">Unsigned 64-bit integer</param>
			/// <returns>Result</returns>
            [DebuggerStepThrough]
            public static ulong crc32_u64(ulong crc_ul, ulong v)
            {
                uint crc = (uint)crc_ul;

                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v); v >>= 8;
                crc = crc32_u8(crc, (byte)v);

                return crc;
            }
        }
    }
}