Поиск "рисунка" бит во входном файле

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
 
namespace Matrix64
{
    class Program
    {
        static byte[] buf = new byte[512]; // буфер для файла
        static int blocksCount = 0; // всего блоков в файле (кратно 512)
        static int comparedCount = 0; // общее число совпадений с шаблоном
        static int maxCount = 0; // максимальное число совпадений для одного блока
        static int emptyCount = 0; // число блоков, где нет совпадений совсем
        
        // шаблон для поиска с относительными координатами от левого верхнего угла и значением бита {X, Y, BIT}
        static int[,] XY = { {1, 0, 0}, {2, 0, 1}, {0, 1, 1}, {3, 1, 0}, {0, 2, 0}, {3, 2, 1}, {1, 3, 1}, {2, 3, 0} };
 
        static void Main(string[] args)
        {
            string filePath = @"c:\drivers\temp\bits.7z"; // путь к файлу
            Console.WriteLine("Чтение из файла " + filePath);
 
            // конструктор ProgressBar немного переделал, есть возможность настраивать длину полосы, отображение процентов и анимации
            using (var progress = new ProgressBar(50, true)) // можно убрать если нет желания смотреть на полосу прогресса
            using (var infile = File.OpenRead(filePath))
            {
                while (true)
                {
 
                    progress.Report((double)blocksCount / (infile.Length / 512)); // можно убрать если нет желания смотреть на полосу прогресса
                    var bytesRead = ReadBlock(infile, buf);
                    if (bytesRead == 0)
                        break;
                    int tempMaxCount = 0;
                    for (int x = 0; x < 60; x++) // по идее вместо 60 должна стоять формула для подсчета ширины мартицы согласно проверяемому шаблону
                        for (int y = 0; y < 60; y++)
                            if (SearchIcon(x, y, XY))
                            {
                                comparedCount++;
                                tempMaxCount++;
                            }
                    if (tempMaxCount == 0) emptyCount++;
                    if (tempMaxCount > maxCount) maxCount = tempMaxCount;
                    blocksCount++;
                    //Thread.Sleep(1);
                }
            }
            Console.WriteLine("Done.");
            Console.WriteLine("Совпадений: {0}", comparedCount);
            Console.WriteLine("Всего блоков: {0} / Блоков без аномалий: {1} ({2}%)", blocksCount, emptyCount, emptyCount * 100 / blocksCount);
            Console.WriteLine("Совпадений на блок (среднее): {0}", comparedCount / blocksCount);
            Console.WriteLine("Совпадений на блок (макс): {0}", maxCount);
            Console.ReadKey();
        }
 
        // проверка всех битов из массива шаблона
        static bool SearchIcon(int x, int y, int[,] xy)
        {
            for (int pos = 0; pos < xy.Length / 3; pos++)
                if (!IsSet(x + xy[pos, 0], y + xy[pos, 1], xy[pos, 2])) return false;
            return true;
        }
 
        // проверка одного бита согласно координатам в матрице
        static bool IsSet(int x, int y, int bit)
        {
            return ((buf[y * 8 + x / 8] & (int)Math.Pow(2, 7 - (x < 8 ? x : x % 8))) == 0 ? 0 : 1) == bit ? true : false;
        }
 
        // стырено откуда-то, читает блоками файл
        static int ReadBlock(Stream s, byte[] block)
        {
            int position = 0;
            while (position < block.Length)
            {
                var actuallyRead = s.Read(block, position, block.Length - position);
                if (actuallyRead == 0)
                    break;
                position += actuallyRead;
            }
            return position;
        }
    }
}

using System;
using System.Text;
using System.Threading;
 
/// <summary>
/// An ASCII progress bar
/// </summary>
public class ProgressBar : IDisposable, IProgress<double> {
    private int blockCount = 30;
    private bool spercent = false;
    private bool sanimation = false;
    private readonly TimeSpan animationInterval = TimeSpan.FromSeconds(1.0 / 8);
    private const string animation = @"|/-\";
 
    private readonly Timer timer;
 
    private double currentProgress = 0;
    private string currentText = string.Empty;
    private bool disposed = false;
    private int animationIndex = 0;
 
    public ProgressBar(int _blkCount, bool _percent = false, bool _sanimation = false) {
        timer = new Timer(TimerHandler);
        blockCount = _blkCount;
        spercent = _percent;
        sanimation = _sanimation;
        // A progress bar is only for temporary display in a console window.
        // If the console output is redirected to a file, draw nothing.
        // Otherwise, we'll end up with a lot of garbage in the target file.
        if (!Console.IsOutputRedirected) {
            ResetTimer();
        }
    }
 
    public void Report(double value) {
        // Make sure value is in [0..1] range
        value = Math.Max(0, Math.Min(1, value));
        Interlocked.Exchange(ref currentProgress, value);
    }
 
    private void TimerHandler(object state) {
        lock (timer) {
            if (disposed) return;
 
            int progressBlockCount = (int) (currentProgress * blockCount);
            int percent = (int) (currentProgress * 100);
            string text;
            if (sanimation)
                text = spercent ? string.Format("[{0}{1}] {2,3}% {3}", new string('#', progressBlockCount), new string('.', blockCount - progressBlockCount), percent, animation[animationIndex++ % animation.Length]) :
                                        string.Format("[{0}{1}] {2}", new string('#', progressBlockCount), new string('.', blockCount - progressBlockCount), animation[animationIndex++ % animation.Length]);
            else
                text = spercent ? string.Format("[{0}{1}] {2,3}%", new string('#', progressBlockCount), new string('.', blockCount - progressBlockCount), percent) :
                                        string.Format("[{0}{1}]", new string('#', progressBlockCount), new string('.', blockCount - progressBlockCount));
            /*string text = string.Format("[{0}{1}] {2,3}% {3}",
                new string('#', progressBlockCount), new string('.', blockCount - progressBlockCount),
                percent,
                animation[animationIndex++ % animation.Length]);*/
            UpdateText(text);
 
            ResetTimer();
        }
    }
 
    private void UpdateText(string text) {
        // Get length of common portion
        int commonPrefixLength = 0;
        int commonLength = Math.Min(currentText.Length, text.Length);
        while (commonPrefixLength < commonLength && text[commonPrefixLength] == currentText[commonPrefixLength]) {
            commonPrefixLength++;
        }
 
        // Backtrack to the first differing character
        StringBuilder outputBuilder = new StringBuilder();
        outputBuilder.Append('\b', currentText.Length - commonPrefixLength);
 
        // Output new suffix
        outputBuilder.Append(text.Substring(commonPrefixLength));
 
        // If the new text is shorter than the old one: delete overlapping characters
        int overlapCount = currentText.Length - text.Length;
        if (overlapCount > 0) {
            outputBuilder.Append(' ', overlapCount);
            outputBuilder.Append('\b', overlapCount);
        }
 
        Console.Write(outputBuilder);
        currentText = text;
    }
 
    private void ResetTimer() {
        timer.Change(animationInterval, TimeSpan.FromMilliseconds(-1));
    }
 
    public void Dispose() {
        lock (timer) {
            disposed = true;
            UpdateText(string.Empty);
        }
    }
 
}