Варианты конвертации bool/byte/int в byte/int

using System;
using System.Diagnostics;
 
namespace CalcBitsCL
{
    class Program
    {
        static object locker = new object();
 
        // это расчётные значения для работы с матрицей 5х5, но с фиксированным одним значение верхнего элемента, я тестировал со значением 0, но работает и с любым но одиночным значением
        // это большая оптимизация которая позволила резко сократить число операций, значения в массиве обозначают места для разных значений SumBits
        // идея в том, что сравнивать одни данные с другими имеет смысла только если суммы бит одинаковые, так мы сокращаем число итераций для For(Compare)
        public static readonly int[] DimIdx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
        public static int[] countNidx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
 
        public static DimBitsS[] DimBitsSN = new DimBitsS[1048576]; // число элементов матрицы 5х5, но для одного значения верхнего вектора, то есть формально 2 в двадцатой степени + 1
        public static byte SumBits = 0; // хранит сумму бит, является так же индексом для DimIdx и countNidx
 
        public static byte x1, x2, x3, x4, x5; // числа, используемые для отражения значений матрицы 5х5, x1 - верх, x5 - низ
 
        public static ulong countN = 0; public static ulong countIn = 0; public static ulong countX, old_countX; public static int num1, num2;
 
        public struct DimBitsS
        {
            public byte[] Bits; // массив сумм бит
            public int Sum; // значение SumBits сохранённое во время расчета каждого элемента
            public byte Hash; // XOR хэш
            public byte CRC8; // CRC8
 
            public DimBitsS(int _Sum) // инициализация
            {
                this.Sum = _Sum;
                this.Hash = 0;
                this.CRC8 = 0;
                this.Bits = new byte[28];
            }
        }
 
        public static void Compare(int y)
        {
        }
 
        public static byte BitCount(ulong value) // считаем число бит в переменной
        {
            ulong result = value - ((value >> 1) & 0x5555555555555555UL);
            result = (result & 0x3333333333333333UL) + ((result >> 2) & 0x3333333333333333UL);
            return (byte)(unchecked(((result + (result >> 4)) & 0xF0F0F0F0F0F0F0FUL) * 0x101010101010101UL) >> 56);
        }
 
        static class CRC8 // расчет CRC8, нужно такое же, но на CRC32
        {
            static byte[] CRC8_TABLE = new byte[]{
                0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
                157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
                35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
                190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
                70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
                219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
                101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
                248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
                140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
                17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
                175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
                50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
                202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
                87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
                233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
                116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 };
 
            public static byte Calculate(byte[] data, byte init = 0)
            {
                byte result = init;
                for (var i = 0; i < 20/*data.Length*/; i++) // по алгоритму конечно надо ставить data.Length, но для моего алгоритма это значение 28, а лучшую скорость даёт 20
                {
                    result = CRC8_TABLE[result ^ data[i]];
                }
                return result;
            }
        }
 
        static void Main(string[] args)
        {
            int temp, old_percent = 0; // инициализация счетчиков и временных переменных
            num1 = 0; num2 = 0;
            if (num1 >= num2) num2 = num1 + 1; else num2++; // по большому счёту нужно только если первое и второе значения менять, если ничего не трогать, то можно не обращать внимание
            for (x1 = (byte)num1; x1 < (byte)num2; x1++) // первая переменная из матрицы 5х5 бит (условно верхняя)
            {
                countN = 0; countX = 0; old_countX = 0; // инициализация счетчиков
                var sw = Stopwatch.StartNew(); // запуск таймера
                for (x2 = 0; x2 < 32; x2++) // вторая переменная из матрицы
                {
                    // обновление элементов на форме, происходит только если данные изменились
                    temp = (int)((ulong)countN * (ulong)(x1 + 1) * 100 / (ulong)(Math.Pow(32, 4) * (num2 - num1))); // тут я набредил и больше не трогал, используется для вычисления шкалы ProgressBar, нормально работает для одного значения x1, по если x1 > 0 будет показывать криво
                                                                                                                    // обновление ProgressBar и Label с процентом
                    // порой достаточно посмотреть 50% от всей программы (это примерно 33% от всего объёма вычислений)
                    if (old_percent != temp)
                    {
                        Console.WriteLine(temp.ToString() + "%");
                        old_percent = temp;
                    }
                    for (x3 = 0; x3 < 32; x3++) // третья переменная из матрицы
                    {
                        for (x4 = 0; x4 < 32; x4++) // четвертая из матрицы
                        {
                            for (x5 = 0; x5 < 32; x5++) // пятая переменная
                            {
                                SumBits = (byte)(BitCount(x1) + BitCount(x2) + BitCount(x3) + BitCount(x4) + BitCount(x5)); // сумма сумм бит
                                DimBitsSN[countNidx[SumBits]] = new DimBitsS(SumBits); // инициализация данных в структуре
 
                                // заполнение массива в структуре
                                DimBitsSN[countNidx[SumBits]].Bits[0] = (byte)BitCount(x5); // (byte) тут нужно только если поменять логику вычисления суммы бит
                                DimBitsSN[countNidx[SumBits]].Bits[1] = (byte)BitCount(x4); // можно придумать свои варианты суммирования, например
                                DimBitsSN[countNidx[SumBits]].Bits[2] = (byte)BitCount(x3); // ((x1) == 0 ? 0 : 1)
                                DimBitsSN[countNidx[SumBits]].Bits[3] = (byte)BitCount(x2); // в таком случае оптимизации нужно подстраивать под контекст
                                DimBitsSN[countNidx[SumBits]].Bits[4] = (byte)BitCount(x1); // например для моих алгоритвом расчёта я выяснил какие именно данные чаще меняются
                                DimBitsSN[countNidx[SumBits]].Bits[5] = (byte)BitCount(x5); // и отсортировал их в этом массиве, где 0 - часто, 27 - редко
                                DimBitsSN[countNidx[SumBits]].Bits[6] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[7] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[8] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[9] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[10] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[11] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[12] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[13] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[14] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[15] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[16] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[17] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[18] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[19] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[20] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[21] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[22] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[23] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[24] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[25] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[26] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[27] = (byte)BitCount(x3);
 
                                // заполняем CRC8
                                DimBitsSN[countNidx[SumBits]].CRC8 = CRC8.Calculate(DimBitsSN[countNidx[SumBits]].Bits);
 
                                // считаем и заполняем XOR хэш
                                for (var h = 0; h < 3; h++) DimBitsSN[countNidx[SumBits]].Hash ^= DimBitsSN[countNidx[SumBits]].Bits[h];
 
                                // запускаем основной цикл сравнения. Условие смотрит только за тем, чтобы проверка запускалась только если более одного значения посчитано
                                if (countN > 0 && DimIdx[SumBits] != countNidx[SumBits])
                                {
                                    for (var i = DimIdx[SumBits]; i < (DimIdx[SumBits] == countNidx[SumBits] ? countNidx[SumBits] + 1 : countNidx[SumBits]); i++)
                                    {
                                        if (DimBitsSN[countNidx[SumBits]].Hash == DimBitsSN[i].Hash)
                                        {   // этот хэш простой XOR, число переменных выбирается
                                            // в BackgroundThreadFunc() до вызова For(Compare),
                                            // текущее значение выбрано опытным путём
                                            if (DimBitsSN[countNidx[SumBits]].CRC8 == DimBitsSN[i].CRC8) // функция взята с одной из тем Cyberforum
                                                                                                         // тоже не иду по всем byte[], значение подобрано
                                            {
                                                countIn++; // так увидим число входов, оно определяет продолжительность вычислений
                                                for (var n = 0; n < 24; n++)
                                                {
                                                    if (DimBitsSN[countNidx[SumBits]].Bits[n] == DimBitsSN[i].Bits[n])
                                                    // если прошли через хэши, то проверяем от частого к редкому и отлавливаем совпавшие
                                                    {
                                                        countX++; // число совпавших
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
 
                                countN++; // общее число итераций
                                countNidx[SumBits]++; // движение указателей на данные
                            }
                        }
                    }
                }
                sw.Stop(); // таймер времени выполнения программы
                Console.WriteLine(countIn.ToString() + " : " + countX.ToString() + " : " + sw.Elapsed.ToString());
            }
            Console.WriteLine("Цимес!!! Прес эни кий ту континью...");
            Console.ReadKey();
        }
    }
}