Как быстро определять наличие строк в файле, при этом не засоряя ОЗУ?

using System.Text;
 
string source = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";
var random = new Random();
var length = 38;
var indexes = new byte[length];
var arr = new char[length];
 
const long size = 1024L * 1024 * 1024 * 3;
 
using var file = new StreamWriter(@"E:\anime temp\big", false, Encoding.UTF8);
var i = 0L;
 
 
while (file.BaseStream.Position < size)
{
    file.WriteLine(Genareate());
}
 
string Genareate()
{
    random.NextBytes(indexes);
    for (var i = 0; i < length; i++)
    {
        arr[i] = source[indexes[i] % length];
    }
    return new string(arr);
}

using System.Collections;
using System.Diagnostics;
using System.Text;
 
const string fileName = @"E:\anime temp\big";
const int countItaration = 50_000;
var encoding = Encoding.UTF8;
 
var itemSource = new InputValueSource(countItaration);
Test(Nya, "финальный прогон");
 
Console.WriteLine();
Console.WriteLine("Nya!");
Console.ReadKey();
 
void Test(Action action, string name)
{
    Console.WriteLine();
    var sw = Stopwatch.StartNew();
    action();
    sw.Stop();
    Console.WriteLine($"{name} - {sw.Elapsed}");
}
 
void FindedAction(string line) { Console.WriteLine(line); }
 
void Nya()
{
    Dictionary<byte, byte[]> ReadAllFile()
    {
        using var file = new StreamReader(fileName, encoding);
 
        var dic = new Dictionary<byte, MemoryStream>();
 
        try
        {
            string? line;
 
            while ((line = file.ReadLine()) != null)
            {
                var arr = NyaConvertor.ToBytes(line);
                var key = arr[0];
                MemoryStream? memory;
                if(!dic.TryGetValue(key, out memory))
                    dic[key] = memory = new MemoryStream();
                memory.Write(arr, 1, arr.Length - 1);
            }
 
            return dic.ToDictionary(x => x.Key, x => x.Value.ToArray());
        }
        finally
        { 
            foreach(var m in dic.Values)
                m.Dispose();
        }
    }
 
    var cache = ReadAllFile();
    GC.Collect();
 
    var skeepSize = NyaConvertor.GetCacheSize(Settings.WordSize);
    foreach (var searchLine in itemSource)
    {
        var word = NyaConvertor.ToBytes(searchLine);
 
        if (cache.TryGetValue(word[0], out var memory))
        {
            var indexWord = 1;
            for (var i = 0; i < memory.Length;)
            {
                if (memory[i] == word[indexWord])
                {
                    indexWord++;
                    i++;
                    if (indexWord == word.Length)
                    {
                        FindedAction(searchLine);
                        break;
                    }
                }
                else
                {
                    i += skeepSize - indexWord;
                    indexWord = 1;
                }
            }
        }  
    }
}
 
static class Settings
{ 
    public static readonly string Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";
    public const int WordSize = 38;
}
 
class InputValueSource : IEnumerable<string>
{
    private const int wordSize = Settings.WordSize;
    private static readonly Random random = new();
    private static byte[] indexes = new byte[wordSize];
    private static char[] arr = new char[wordSize];
    private readonly IReadOnlyCollection<string> _items;
 
    public InputValueSource(int size)
    {
        var items = new string[size];
        for (var i = 0; i < size; i++)
            items[i] = Genareate();
        //items[0] = "MEgEYPSLOLSOZYPlbMVOQajJaWGVbBFefJWGVV";
        //items[10] = "MEgEYPSLOLSOZYPlbMVOQajJaWGVbBFefJWGVe";
        //items[20] = "aMCZGSWUJbeHjcBTRJMaeWdhfAfgZUcFbfMVHP";
        //items[30] = "YgEbPYTgMhCBIRhGWHCObSQPUIaUQFMEMXjhCa";
        _items = items;
    }
 
    public IEnumerator<string> GetEnumerator()
        => _items.GetEnumerator();
 
    IEnumerator IEnumerable.GetEnumerator()
        => _items.GetEnumerator();
    private static string Genareate()
    {
        random.NextBytes(indexes);
        for (var i = 0; i < wordSize; i++)
        {
            arr[i] = Settings.Alphabet[indexes[i] % wordSize];
        }
        return new string(arr);
    }
}
 
static class NyaConvertor
{
    private static readonly IReadOnlyDictionary<char, byte> _dic;
 
    static NyaConvertor()
    {
        var dic = new Dictionary<char, byte>();
 
        byte val = 1;
        foreach (var c in Settings.Alphabet)
        {
            dic.Add(c, val++);
            if (val > 64)
                throw new Exception("невозможно сжать данные");
        }
 
        _dic = dic;
    }
 
    public static byte[] ToBytes(string input)
    {
        var output = new byte[GetCacheSize(input.Length)];
        var iteration = 0;
        var buff = 0;
        var i = 0;
        foreach (var c in input)
        {
            buff = (buff << 4) | _dic[c];
 
            iteration++;
            if (iteration == 4)
            {
                iteration = 0;
                output[i++] = (byte)buff;
            }
        }
 
        if(iteration != 0)
            output[i] = (byte)buff;
 
        return output;
    }
 
    public static int GetCacheSize(int inputSize)
        => inputSize / 4 + (inputSize % 4 > 0 ? 1 : 0);
}