private static uint f0(uint B, uint C, uint D) => ((B & C) | ((~B) & D));
        private static uint f1(uint B, uint C, uint D) => (B ^ C ^ D);
        private static uint f2(uint B, uint C, uint D) => ((B & C) | (B & D) | (C & D));
        private static uint f3(uint B, uint C, uint D) => (B ^ C ^ D);

        static void SHA1ProcessMessageBlock(SHA1Context context)
        {
            uint[] W = InitializeWordSequence(context.Message_Block);

            var hash = context.Intermediate_Hash;
            Func<uint, uint, uint, uint>[] f = { f0, f1, f2, f3 };
            UInt32[] K = { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
            var (A, B, C, D, E) = (hash[0], hash[1], hash[2], hash[3], hash[4]);

            for (var i = 1; i <= 4; i++)
            {
                (A, B, C, D, E) = DoIntermediateHashCalculationRounds(i * 20, (i + 1) * 20, K[i], f[i], W, A, B, C, D, E);
            }

            hash[0] += A;
            hash[1] += B;
            hash[2] += C;
            hash[3] += D;
            hash[4] += E;

            context.Message_Block_Index = 0;
        }

        private static uint[] InitializeWordSequence(byte[] messageBlock)
        {
            var W = new UInt32[80];  /* Word sequence               */
            /* Initialize the first 16 words in the array W    */
            InitializeFirst16WordsInW(messageBlock, W);
            FillRestOfWFromFirst16(W);
            return W;
        }

        private static void InitializeFirst16WordsInW(byte[] messageBlock, uint[] W)
        {
            for (var i = 0; i < 16; i++)
            {
                W[i] = (UInt32)messageBlock[i * 4] << 24;
                W[i] |= (UInt32)messageBlock[i * 4 + 1] << 16;
                W[i] |= (UInt32)messageBlock[i * 4 + 2] << 8;
                W[i] |= (UInt32)messageBlock[i * 4 + 3];
            }
        }

        private static void FillRestOfWFromFirst16(uint[] W)
        {
            for (var i = 16; i < 80; i++)
            {
                W[i] = SHA1CircularShift(1, W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
            }
        }

        private static (UInt32 A, UInt32 B, UInt32 C, UInt32 D, UInt32 E) DoIntermediateHashCalculationRounds(
            int startIndex,
            int firstIndexAfterEnd,
            uint K,
            Func<uint, uint, uint, uint> f,
            uint[] W,
            uint A,
            uint B,
            uint C,
            uint D,
            uint E)
        {
            for (var i = startIndex; i < firstIndexAfterEnd; i++)
            {
                var nextA = SHA1CircularShift(5, A) + f(B, C, D) + E + W[i] + K;
                E = D;
                D = C;
                C = SHA1CircularShift(30, B);
                B = A;
                A = nextA;
            }
            return (A, B, C, D, E);
        }