LastIndexOfAny() [2/2]

static int System.SpanHelpers.LastIndexOfAny ( ref byte searchSpace, byte value0, byte value1, int length )

inlinestatic

Definition at line 933 of file SpanHelpers.cs.

    {
        nuint num = (uint)length;
        nuint num2 = (uint)length;
        if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
        {
            num2 = UnalignedCountVectorFromEnd(ref searchSpace, length);
        }
        while (true)
        {
            if (num2 >= 8)
            {
                num2 -= 8;
                num -= 8;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
                if (value0 == num3 || value1 == num3)
                {
                    break;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
                if (value0 != num3 && value1 != num3)
                {
                    num3 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
                    if (value0 != num3 && value1 != num3)
                    {
                        num3 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
                        if (value0 != num3 && value1 != num3)
                        {
                            num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
                            if (value0 != num3 && value1 != num3)
                            {
                                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
                                if (value0 != num3 && value1 != num3)
                                {
                                    num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
                                    if (value0 != num3 && value1 != num3)
                                    {
                                        num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                                        if (value0 != num3 && value1 != num3)
                                        {
                                            continue;
                                        }
                                        goto IL_027c;
                                    }
                                    goto IL_027f;
                                }
                                goto IL_0285;
                            }
                            goto IL_028b;
                        }
                        return (int)(num + 4);
                    }
                    return (int)(num + 5);
                }
                return (int)(num + 6);
            }
            if (num2 >= 4)
            {
                num2 -= 4;
                num -= 4;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
                if (value0 == num3 || value1 == num3)
                {
                    goto IL_028b;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
                if (value0 == num3 || value1 == num3)
                {
                    goto IL_0285;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
                if (value0 == num3 || value1 == num3)
                {
                    goto IL_027f;
                }
                num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                if (value0 == num3 || value1 == num3)
                {
                    goto IL_027c;
                }
            }
            while (num2 != 0)
            {
                num2--;
                num--;
                uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
                if (value0 != num3 && value1 != num3)
                {
                    continue;
                }
                goto IL_027c;
            }
            if (Vector.IsHardwareAccelerated && num != 0)
            {
                num2 = num & (nuint)(~(Vector<byte>.Count - 1));
                Vector<byte> right = new Vector<byte>(value0);
                Vector<byte> right2 = new Vector<byte>(value1);
                while (num2 > (nuint)(Vector<byte>.Count - 1))
                {
                    Vector<byte> left = LoadVector(ref searchSpace, num - (nuint)Vector<byte>.Count);
                    Vector<byte> vector = Vector.BitwiseOr(Vector.Equals(left, right), Vector.Equals(left, right2));
                    if (Vector<byte>.Zero.Equals(vector))
                    {
                        num -= (nuint)Vector<byte>.Count;
                        num2 -= (nuint)Vector<byte>.Count;
                        continue;
                    }
                    return (int)num - Vector<byte>.Count + LocateLastFoundByte(vector);
                }
                if (num != 0)
                {
                    num2 = num;
                    continue;
                }
            }
            return -1;
            IL_027c:
            return (int)num;
            IL_028b:
            return (int)(num + 3);
            IL_027f:
            return (int)(num + 1);
            IL_0285:
            return (int)(num + 2);
        }
        return (int)(num + 7);
    }

References System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Numerics.Vector< T >.Equals(), System.Numerics.Vector< T >.IsHardwareAccelerated, System.length, System.SpanHelpers.LoadVector(), System.SpanHelpers.LocateLastFoundByte(), and System.SpanHelpers.UnalignedCountVectorFromEnd().

Referenced by System.MemoryExtensions.LastIndexOfAny< T >(), System.MemoryExtensions.LastIndexOfAny< T >(), System.MemoryExtensions.LastIndexOfAny< T >(), System.MemoryExtensions.LastIndexOfAny< T >(), System.MemoryExtensions.LastIndexOfAny< T >(), and System.MemoryExtensions.LastIndexOfAny< T >().