Приемлема ли такая реализация поиска в списке?

    [Benchmark]
    public void NaiveTest()
    {
        var length = 65536;
        var index = random.Next(list7.Length - length + 1);
        var n = random.Next(length);
        for (var i = 0; i < length; i++)
            if (bigList[index + i] == n)
            {
                _ = index + i;
                return;
            }
    }
 
    [Benchmark]
    public void ProgressiveTest()
    {
        var length = 65536;
        var index = random.Next(list7.Length - length + 1);
        var n = random.Next(length);
        _ = bigList.IndexOf(n, index, length);
    }

    private double Direct(int x)
    {
        if (x <= 0)
            return 1;
        if (random.Next(2) == 1)
            return x * Direct(x - 1);
        else
            return x * Direct(x - 1);
    }
 
    private double Ping(int x)
    {
        if (x <= 0)
            return 1;
        if (random.Next(2) == 1)
            return x * Ping(x - 1);
        else
            return x * Pong(x - 1);
    }
 
    private double Pong(int x)
    {
        if (x <= 0)
            return 1;
        if (random.Next(2) == 1)
            return x * Ping(x - 1);
        else
            return x * Pong(x - 1);
    }
 
    [Benchmark]
    public void DirectTest()
    {
        Direct(100);
    }
 
    [Benchmark]
    public void IndirectTest()
    {
        Ping(100);
    }

    private protected override MpzT IndexOfInternal(T item, MpzT index, MpzT length, bool fromEnd)
    {
        if (length == 0)
            return -1;
        if (low != null)
            return IndexOfTrivial(item, ref index, length, fromEnd);
        else if (high == null || highLength == null)
            throw new ApplicationException("Произошла серьезная ошибка при попытке выполнить действие. К сожалению, причина ошибки неизвестна.");
        var endIndex = index + length - 1;
        var bReversedOld = bReversed;
        if (bReversedOld)
        {
            Reverse();
            (index, endIndex) = (Length - 1 - endIndex, Length - 1 - index);
            fromEnd = !fromEnd;
        }
        try
        {
            var intIndex = highLength.IndexOfNotGreaterSum(index, out var bitsIndex);
            var endIntIndex = highLength.IndexOfNotGreaterSum(endIndex, out var endBitsIndex);
            while (endBitsIndex >= fragment)
            {
                endIntIndex++;
                endBitsIndex -= fragment;
            }
            if (intIndex != 0 && intIndex == highLength.Length && bitsIndex == 0 && highLength[intIndex - 1] != fragment)
            {
                intIndex--;
                bitsIndex = highLength[^1];
            }
            MpzT foundIndex;
            if (intIndex == endIntIndex)
            {
                foundIndex = high[intIndex].IndexOfInternal(item, bitsIndex, length, fromEnd);
                if (foundIndex >= 0)
                {
                    foundIndex += index - bitsIndex;
                    return bReversedOld ? Length - 1 - foundIndex : foundIndex;
                }
                return foundIndex;
            }
            MpzT offset;
            if (fromEnd)
            {
                offset = endIndex - endBitsIndex;
                foundIndex = high[endIntIndex].IndexOfInternal(item, 0, endBitsIndex + 1, true);
                if (foundIndex >= 0)
                    return bReversedOld ? Length - 1 - offset - foundIndex : offset + foundIndex;
                offset -= high[endIntIndex - 1].Length;
            }
            else
            {
                offset = index - bitsIndex;
                foundIndex = high[intIndex].IndexOfInternal(item, bitsIndex, high[intIndex].Length - bitsIndex, false);
                if (foundIndex >= 0)
                    return bReversedOld ? Length - 1 - offset - foundIndex : offset + foundIndex;
                offset += high[intIndex].Length;
            }
            for (var i = fromEnd ? endIntIndex - 1 : intIndex + 1;
                fromEnd ? i > intIndex : i < endIntIndex; i += fromEnd ? -1 : 1)
            {
                foundIndex = high[i].IndexOfInternal(item, 0, high[i].Length, fromEnd);
                if (foundIndex >= 0)
                    return bReversedOld ? Length - 1 - offset - foundIndex : offset + foundIndex;
                offset += fromEnd ? -high[i - 1].Length : high[i].Length;
            }
            if (fromEnd)
            {
                foundIndex = high[intIndex].IndexOfInternal(item, bitsIndex, high[intIndex].Length - bitsIndex, true);
                if (foundIndex >= 0)
                    return bReversedOld ? Length - 1 - offset - foundIndex : offset + foundIndex;
            }
            else
            {
                foundIndex = high[endIntIndex].IndexOfInternal(item, 0, endBitsIndex + 1, false);
                if (foundIndex >= 0)
                    return bReversedOld ? Length - 1 - offset - foundIndex : offset + foundIndex;
            }
            return -1;
        }
        finally
        {
            if (bReversedOld)
                Reverse();
        }
    }
 
    private protected virtual MpzT IndexOfTrivial(T item, ref MpzT index, MpzT length, bool fromEnd)
    {
        Debug.Assert(low != null);
        Debug.Assert(index < int.MaxValue - 1);
        Func<T, int, int, int> func = bReversed ^ fromEnd ? low.LastIndexOf : low.IndexOf;
        if (fromEnd)
        {
            index += length - 1;
        }
        if (bReversed)
        {
            var foundIndex = func(item, (int)(Length - 1 - index), (int)length);
            return foundIndex >= 0 ? Length - 1 - foundIndex : foundIndex;
        }
        else
            return func(item, (int)index, (int)length);
    }