Где ошибка в кастомной реализации MD5?

Дана кастомная реализация MD5, найденная на просторах сети.

На определенных размерах буфера (указаны в примере) кастомная реализация MD5 выдает результат, отличный от результата стандартных функций дотнета.

Ради чего я вообще это затеял: кастомная реализация работает в 1.5 - 5 раз быстрее стандартной на массивах небольшого размера.

Я сам пробовал найти ошибку, но не могу. В большинстве случаев хеш вычисляется корректно. В чем заключается ошибка в кастомной реализации?

using System;
using System.Runtime.InteropServices;
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            // Проблема в том, что когда размер buffer (массив байт, MD5 хеш которого нужно вычислить)
            // составляет 120, 248, 312, 376 - то хеш вычисляется некорректно, по сравнению со стадартным 
            // методом .NET. В остальных случаях хеш вычисляется корректно.
            var buffer = new byte[120];
            Console.WriteLine("Unmanaged result:\t" + string.Join(" ", MD5Unmanaged.ComputeHash(buffer)));
            Console.WriteLine("Managed result:\t\t" + string.Join(" ", MD5Managed.ComputeHash(buffer)));
            Console.ReadKey();
        }
    }
    // MD5 .NET implementation
    internal static class MD5Unmanaged
    {
        internal static byte[] ComputeHash(byte[] input)
        {
            using (var md5 = System.Security.Cryptography.MD5.Create())
                return md5.ComputeHash(input);
        }
    }
    // MD5 custome implementation
    internal static class MD5Managed
    {
        [StructLayout(LayoutKind.Sequential)]
        struct MD5_ABCD
        {
            public uint A;
            public uint B;
            public uint C;
            public uint D;
        }
        internal static byte[] ComputeHash(byte[] input)
        {
            var md5Abcd = new MD5_ABCD
            {
                A = 0x67452301U,
                B = 0xefcdab89,
                C = 0x98badcfe,
                D = 0x10325476U
            };
            int ibStart = 0;
            while (ibStart <= (input.Length - 64))
            {
                GetHashBlock(input, ref md5Abcd, ibStart);
                ibStart += 64;
            }
            return GetHashFinalBlock(input, ibStart, input.Length - ibStart, md5Abcd, input.Length * 8L);
        }
        private static uint[] Converte(byte[] input, int ibStart)
        {
            var result = new uint[16];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = input[ibStart + (i * 4)];
                result[i] += (uint)(input[(ibStart + (i * 4)) + 1] << 8);
                result[i] += (uint)(input[(ibStart + (i * 4)) + 2] << 16);
                result[i] += (uint)(input[(ibStart + (i * 4)) + 3] << 24);
            }
            return result;
        }
        private static void GetHashBlock(byte[] input, ref MD5_ABCD md5Abcd, int ibStart)
        {
            var numArray = Converte(input, ibStart);
            uint a = md5Abcd.A;
            uint b = md5Abcd.B;
            uint c = md5Abcd.C;
            uint d = md5Abcd.D;
            a = R1(a, b, c, d, numArray[0], 7, 0xd76aa478);
            d = R1(d, a, b, c, numArray[1], 12, 0xe8c7b756);
            c = R1(c, d, a, b, numArray[2], 0x11, 0x242070db);
            b = R1(b, c, d, a, numArray[3], 0x16, 0xc1bdceee);
            a = R1(a, b, c, d, numArray[4], 7, 0xf57c0faf);
            d = R1(d, a, b, c, numArray[5], 12, 0x4787c62a);
            c = R1(c, d, a, b, numArray[6], 0x11, 0xa8304613);
            b = R1(b, c, d, a, numArray[7], 0x16, 0xfd469501);
            a = R1(a, b, c, d, numArray[8], 7, 0x698098d8);
            d = R1(d, a, b, c, numArray[9], 12, 0x8b44f7af);
            c = R1(c, d, a, b, numArray[10], 0x11, 0xffff5bb1);
            b = R1(b, c, d, a, numArray[11], 0x16, 0x895cd7be);
            a = R1(a, b, c, d, numArray[12], 7, 0x6b901122);
            d = R1(d, a, b, c, numArray[13], 12, 0xfd987193);
            c = R1(c, d, a, b, numArray[14], 0x11, 0xa679438e);
            b = R1(b, c, d, a, numArray[15], 0x16, 0x49b40821);
            a = R2(a, b, c, d, numArray[1], 5, 0xf61e2562);
            d = R2(d, a, b, c, numArray[6], 9, 0xc040b340);
            c = R2(c, d, a, b, numArray[11], 14, 0x265e5a51);
            b = R2(b, c, d, a, numArray[0], 20, 0xe9b6c7aa);
            a = R2(a, b, c, d, numArray[5], 5, 0xd62f105d);
            d = R2(d, a, b, c, numArray[10], 9, 0x2441453);
            c = R2(c, d, a, b, numArray[15], 14, 0xd8a1e681);
            b = R2(b, c, d, a, numArray[4], 20, 0xe7d3fbc8);
            a = R2(a, b, c, d, numArray[9], 5, 0x21e1cde6);
            d = R2(d, a, b, c, numArray[14], 9, 0xc33707d6);
            c = R2(c, d, a, b, numArray[3], 14, 0xf4d50d87);
            b = R2(b, c, d, a, numArray[8], 20, 0x455a14ed);
            a = R2(a, b, c, d, numArray[13], 5, 0xa9e3e905);
            d = R2(d, a, b, c, numArray[2], 9, 0xfcefa3f8);
            c = R2(c, d, a, b, numArray[7], 14, 0x676f02d9);
            b = R2(b, c, d, a, numArray[12], 20, 0x8d2a4c8a);
            a = R3(a, b, c, d, numArray[5], 4, 0xfffa3942);
            d = R3(d, a, b, c, numArray[8], 11, 0x8771f681);
            c = R3(c, d, a, b, numArray[11], 0x10, 0x6d9d6122);
            b = R3(b, c, d, a, numArray[14], 0x17, 0xfde5380c);
            a = R3(a, b, c, d, numArray[1], 4, 0xa4beea44);
            d = R3(d, a, b, c, numArray[4], 11, 0x4bdecfa9);
            c = R3(c, d, a, b, numArray[7], 0x10, 0xf6bb4b60);
            b = R3(b, c, d, a, numArray[10], 0x17, 0xbebfbc70);
            a = R3(a, b, c, d, numArray[13], 4, 0x289b7ec6);
            d = R3(d, a, b, c, numArray[0], 11, 0xeaa127fa);
            c = R3(c, d, a, b, numArray[3], 0x10, 0xd4ef3085);
            b = R3(b, c, d, a, numArray[6], 0x17, 0x4881d05);
            a = R3(a, b, c, d, numArray[9], 4, 0xd9d4d039);
            d = R3(d, a, b, c, numArray[12], 11, 0xe6db99e5);
            c = R3(c, d, a, b, numArray[15], 0x10, 0x1fa27cf8);
            b = R3(b, c, d, a, numArray[2], 0x17, 0xc4ac5665);
            a = R4(a, b, c, d, numArray[0], 6, 0xf4292244);
            d = R4(d, a, b, c, numArray[7], 10, 0x432aff97);
            c = R4(c, d, a, b, numArray[14], 15, 0xab9423a7);
            b = R4(b, c, d, a, numArray[5], 0x15, 0xfc93a039);
            a = R4(a, b, c, d, numArray[12], 6, 0x655b59c3);
            d = R4(d, a, b, c, numArray[3], 10, 0x8f0ccc92);
            c = R4(c, d, a, b, numArray[10], 15, 0xffeff47d);
            b = R4(b, c, d, a, numArray[1], 0x15, 0x85845dd1);
            a = R4(a, b, c, d, numArray[8], 6, 0x6fa87e4f);
            d = R4(d, a, b, c, numArray[15], 10, 0xfe2ce6e0);
            c = R4(c, d, a, b, numArray[6], 15, 0xa3014314);
            b = R4(b, c, d, a, numArray[13], 0x15, 0x4e0811a1);
            a = R4(a, b, c, d, numArray[4], 6, 0xf7537e82);
            d = R4(d, a, b, c, numArray[11], 10, 0xbd3af235);
            c = R4(c, d, a, b, numArray[2], 15, 0x2ad7d2bb);
            b = R4(b, c, d, a, numArray[9], 0x15, 0xeb86d391);
            md5Abcd.A = a + md5Abcd.A;
            md5Abcd.B = b + md5Abcd.B;
            md5Abcd.C = c + md5Abcd.C;
            md5Abcd.D = d + md5Abcd.D;
        }
        private static byte[] GetHashFinalBlock(byte[] input, int ibStart, int cbSize, MD5_ABCD md5Abcd, long len)
        {
            var destArr = new byte[64];
            var result = new byte[16];
            var bytes = BitConverter.GetBytes(len);
            Array.Copy(input, ibStart, destArr, 0, cbSize);
            destArr[cbSize] = 128;
            if (cbSize <= 56)
            {
                Array.Copy(bytes, 0, destArr, 56, 8);
                GetHashBlock(destArr, ref md5Abcd, 0);
            }
            else
            {
                GetHashBlock(destArr, ref md5Abcd, 0);
                destArr = new byte[64];
                Array.Copy(bytes, 0, destArr, 56, 8);
                GetHashBlock(destArr, ref md5Abcd, 0);
            }
            Array.Copy(BitConverter.GetBytes(md5Abcd.A), 0, result, 0, 4);
            Array.Copy(BitConverter.GetBytes(md5Abcd.B), 0, result, 4, 4);
            Array.Copy(BitConverter.GetBytes(md5Abcd.C), 0, result, 8, 4);
            Array.Copy(BitConverter.GetBytes(md5Abcd.D), 0, result, 12, 4);
            return result;
        }
        private static uint LSR(uint i, int s)
        {
            return ((i << s) | (i >> (32 - s)));
        }
        private static uint R1(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            return (b + LSR(((a + ((b & c) | ((b ^ uint.MaxValue) & d))) + x) + t, s));
        }
        private static uint R2(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            return (b + LSR(((a + ((b & d) | (c & (d ^ uint.MaxValue)))) + x) + t, s));
        }
        private static uint R3(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            return (b + LSR(((a + ((b ^ c) ^ d)) + x) + t, s));
        }
        private static uint R4(uint a, uint b, uint c, uint d, uint x, int s, uint t)
        {
            return (b + LSR(((a + (c ^ (b | (d ^ uint.MaxValue)))) + x) + t, s));
        }
    }
}