Changeset 1428


Ignore:
Timestamp:
May 13, 2010, 5:34:50 PM (12 years ago)
Author:
pretzsch
Message:

MD5Collider: Made some performance optimizations.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/MD5Collider/Algorithm/StevensCollider.cs

    r1355 r1428  
    147147        delegate UInt32 RoundFunctionDelegate(UInt32 b, UInt32 c, UInt32 d);
    148148
    149         UInt32 FF(UInt32 b, UInt32 c, UInt32 d)
    150         { return d ^ (b & (c ^ d)); }
    151 
    152         UInt32 GG(UInt32 b, UInt32 c, UInt32 d)
    153         { return c ^ (d & (b ^ c)); }
    154 
    155         UInt32 HH(UInt32 b, UInt32 c, UInt32 d)
    156         { return b ^ c ^ d; }
    157 
    158         UInt32 II(UInt32 b, UInt32 c, UInt32 d)
    159         { return c ^ (b | ~d); }
    160 
    161         UInt32 RL(UInt32 x, int n)
    162         { return (x << n) | (x >> (32 - n)); }
    163 
    164         UInt32 RR(UInt32 x, int n)
    165         { return (x >> n) | (x << (32 - n)); }
    166 
    167 
    168149        void MD5_REVERSE_STEP(UInt32[] block, UInt32[] Q, int t, UInt32 AC, int RC)
    169150        {
     
    392373
    393374                            UInt32 a = aa, b = bb, c = cc, d = dd;
    394                             MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    395                             MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    396                             MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    397                             MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    398                             MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    399                             MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    400                             MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    401                             MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    402                             MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    403                             MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     375                            MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     376                            MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     377                            MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     378                            MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     379                            MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     380                            MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     381                            MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     382                            MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     383                            MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     384                            MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    404385
    405386                            c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    412393
    413394
    414                             MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    415                             MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    416                             MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    417                             MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    418                             MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    419                             MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    420                             MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    421                             MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    422                             MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    423                             MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    424                             MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    425                             MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    426                             MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     395                            MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     396                            MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     397                            MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     398                            MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     399                            MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     400                            MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     401                            MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     402                            MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     403                            MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     404                            MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     405                            MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     406                            MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     407                            MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    427408                            if (0 != ((b ^ d) & 0x80000000))
    428409                            {
     
    432413
    433414
    434                             MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     415                            MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    435416                            if (0 != ((a ^ c) >> 31))
    436417                            {
     
    438419                                continue;
    439420                            }
    440                             MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     421                            MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    441422                            if (0 == ((b ^ d) >> 31))
    442423                            {
     
    444425                                continue;
    445426                            }
    446                             MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     427                            MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    447428                            if (0 != ((a ^ c) >> 31))
    448429                            {
     
    450431                                continue;
    451432                            }
    452                             MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     433                            MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    453434                            if (0 != ((b ^ d) >> 31))
    454435                            {
     
    456437                                continue;
    457438                            }
    458                             MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     439                            MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    459440                            if (0 != ((a ^ c) >> 31))
    460441                            {
     
    462443                                continue;
    463444                            }
    464                             MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     445                            MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    465446                            if (0 != ((b ^ d) >> 31))
    466447                            {
     
    468449                                continue;
    469450                            }
    470                             MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     451                            MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    471452                            if (0 != ((a ^ c) >> 31))
    472453                            {
     
    474455                                continue;
    475456                            }
    476                             MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     457                            MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    477458                            if (0 != ((b ^ d) >> 31))
    478459                            {
     
    480461                                continue;
    481462                            }
    482                             MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     463                            MD5_STEP_II( ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    483464                            if (0 != ((a ^ c) >> 31))
    484465                            {
     
    486467                                continue;
    487468                            }
    488                             MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     469                            MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    489470                            if (0 != ((b ^ d) >> 31))
    490471                            {
     
    492473                                continue;
    493474                            }
    494                             MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     475                            MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
    495476                            if (0 != ((a ^ c) >> 31))
    496477                            {
     
    498479                                continue;
    499480                            }
    500                             MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     481                            MD5_STEP_II( ref b, c, d, a, block[13], 0x4e0811a1, 21);
    501482                            if (0 == ((b ^ d) >> 31))
    502483                            {
     
    504485                                continue;
    505486                            }
    506                             MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     487                            MD5_STEP_II( ref a, b, c, d, block[4], 0xf7537e82, 6);
    507488                            if (0 != ((a ^ c) >> 31))
    508489                            {
     
    510491                                continue;
    511492                            }
    512                             MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     493                            MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
    513494                            if (0 != ((b ^ d) >> 31))
    514495                            {
     
    516497                                continue;
    517498                            }
    518                             MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     499                            MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    519500                            if (0 != ((a ^ c) >> 31))
    520501                            {
     
    522503                                continue;
    523504                            }
    524                             MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     505                            MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    525506
    526507                            UInt32 IHV1 = b + IV[1];
     
    582563            UInt32 d = ihv[3];
    583564
    584             MD5_STEP(FF, ref a, b, c, d, block[0], 0xd76aa478, 7);
    585             MD5_STEP(FF, ref d, a, b, c, block[1], 0xe8c7b756, 12);
    586             MD5_STEP(FF, ref c, d, a, b, block[2], 0x242070db, 17);
    587             MD5_STEP(FF, ref b, c, d, a, block[3], 0xc1bdceee, 22);
    588             MD5_STEP(FF, ref a, b, c, d, block[4], 0xf57c0faf, 7);
    589             MD5_STEP(FF, ref d, a, b, c, block[5], 0x4787c62a, 12);
    590             MD5_STEP(FF, ref c, d, a, b, block[6], 0xa8304613, 17);
    591             MD5_STEP(FF, ref b, c, d, a, block[7], 0xfd469501, 22);
    592             MD5_STEP(FF, ref a, b, c, d, block[8], 0x698098d8, 7);
    593             MD5_STEP(FF, ref d, a, b, c, block[9], 0x8b44f7af, 12);
    594             MD5_STEP(FF, ref c, d, a, b, block[10], 0xffff5bb1, 17);
    595             MD5_STEP(FF, ref b, c, d, a, block[11], 0x895cd7be, 22);
    596             MD5_STEP(FF, ref a, b, c, d, block[12], 0x6b901122, 7);
    597             MD5_STEP(FF, ref d, a, b, c, block[13], 0xfd987193, 12);
    598             MD5_STEP(FF, ref c, d, a, b, block[14], 0xa679438e, 17);
    599             MD5_STEP(FF, ref b, c, d, a, block[15], 0x49b40821, 22);
    600             MD5_STEP(GG, ref a, b, c, d, block[1], 0xf61e2562, 5);
    601             MD5_STEP(GG, ref d, a, b, c, block[6], 0xc040b340, 9);
    602             MD5_STEP(GG, ref c, d, a, b, block[11], 0x265e5a51, 14);
    603             MD5_STEP(GG, ref b, c, d, a, block[0], 0xe9b6c7aa, 20);
    604             MD5_STEP(GG, ref a, b, c, d, block[5], 0xd62f105d, 5);
    605             MD5_STEP(GG, ref d, a, b, c, block[10], 0x02441453, 9);
    606             MD5_STEP(GG, ref c, d, a, b, block[15], 0xd8a1e681, 14);
    607             MD5_STEP(GG, ref b, c, d, a, block[4], 0xe7d3fbc8, 20);
    608             MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    609             MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    610             MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    611             MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    612             MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    613             MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    614             MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    615             MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    616             MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    617             MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
    618             MD5_STEP(HH, ref c, d, a, b, block[11], 0x6d9d6122, 16);
    619             MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    620             MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    621             MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    622             MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    623             MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    624             MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    625             MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    626             MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    627             MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    628             MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    629             MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    630             MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    631             MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    632             MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    633             MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    634             MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    635             MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    636             MD5_STEP(II, ref  a, b, c, d, block[12], 0x655b59c3, 6);
    637             MD5_STEP(II, ref  d, a, b, c, block[3], 0x8f0ccc92, 10);
    638             MD5_STEP(II, ref  c, d, a, b, block[10], 0xffeff47d, 15);
    639             MD5_STEP(II, ref  b, c, d, a, block[1], 0x85845dd1, 21);
    640             MD5_STEP(II, ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
    641             MD5_STEP(II, ref  d, a, b, c, block[15], 0xfe2ce6e0, 10);
    642             MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    643             MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    644             MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    645             MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    646             MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    647             MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     565            MD5_STEP_FF( ref a, b, c, d, block[0], 0xd76aa478, 7);
     566            MD5_STEP_FF( ref d, a, b, c, block[1], 0xe8c7b756, 12);
     567            MD5_STEP_FF( ref c, d, a, b, block[2], 0x242070db, 17);
     568            MD5_STEP_FF( ref b, c, d, a, block[3], 0xc1bdceee, 22);
     569            MD5_STEP_FF( ref a, b, c, d, block[4], 0xf57c0faf, 7);
     570            MD5_STEP_FF( ref d, a, b, c, block[5], 0x4787c62a, 12);
     571            MD5_STEP_FF( ref c, d, a, b, block[6], 0xa8304613, 17);
     572            MD5_STEP_FF( ref b, c, d, a, block[7], 0xfd469501, 22);
     573            MD5_STEP_FF( ref a, b, c, d, block[8], 0x698098d8, 7);
     574            MD5_STEP_FF( ref d, a, b, c, block[9], 0x8b44f7af, 12);
     575            MD5_STEP_FF( ref c, d, a, b, block[10], 0xffff5bb1, 17);
     576            MD5_STEP_FF( ref b, c, d, a, block[11], 0x895cd7be, 22);
     577            MD5_STEP_FF( ref a, b, c, d, block[12], 0x6b901122, 7);
     578            MD5_STEP_FF( ref d, a, b, c, block[13], 0xfd987193, 12);
     579            MD5_STEP_FF( ref c, d, a, b, block[14], 0xa679438e, 17);
     580            MD5_STEP_FF( ref b, c, d, a, block[15], 0x49b40821, 22);
     581            MD5_STEP_GG( ref a, b, c, d, block[1], 0xf61e2562, 5);
     582            MD5_STEP_GG( ref d, a, b, c, block[6], 0xc040b340, 9);
     583            MD5_STEP_GG( ref c, d, a, b, block[11], 0x265e5a51, 14);
     584            MD5_STEP_GG( ref b, c, d, a, block[0], 0xe9b6c7aa, 20);
     585            MD5_STEP_GG( ref a, b, c, d, block[5], 0xd62f105d, 5);
     586            MD5_STEP_GG( ref d, a, b, c, block[10], 0x02441453, 9);
     587            MD5_STEP_GG( ref c, d, a, b, block[15], 0xd8a1e681, 14);
     588            MD5_STEP_GG( ref b, c, d, a, block[4], 0xe7d3fbc8, 20);
     589            MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     590            MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     591            MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     592            MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     593            MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     594            MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     595            MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     596            MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     597            MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     598            MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
     599            MD5_STEP_HH( ref c, d, a, b, block[11], 0x6d9d6122, 16);
     600            MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     601            MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     602            MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     603            MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     604            MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     605            MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     606            MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     607            MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     608            MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     609            MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     610            MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     611            MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     612            MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
     613            MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
     614            MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
     615            MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
     616            MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
     617            MD5_STEP_II( ref  a, b, c, d, block[12], 0x655b59c3, 6);
     618            MD5_STEP_II( ref  d, a, b, c, block[3], 0x8f0ccc92, 10);
     619            MD5_STEP_II( ref  c, d, a, b, block[10], 0xffeff47d, 15);
     620            MD5_STEP_II( ref  b, c, d, a, block[1], 0x85845dd1, 21);
     621            MD5_STEP_II( ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
     622            MD5_STEP_II( ref  d, a, b, c, block[15], 0xfe2ce6e0, 10);
     623            MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
     624            MD5_STEP_II( ref b, c, d, a, block[13], 0x4e0811a1, 21);
     625            MD5_STEP_II( ref a, b, c, d, block[4], 0xf7537e82, 6);
     626            MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
     627            MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     628            MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    648629
    649630            ihv[0] += a;
     
    656637        {
    657638            a += f(b, c, d) + m + ac;
     639            a = (a << rc | a >> (32 - rc)) + b;
     640        }
     641
     642        UInt32 FF(UInt32 b, UInt32 c, UInt32 d)
     643        { return d ^ (b & (c ^ d)); }
     644
     645        UInt32 GG(UInt32 b, UInt32 c, UInt32 d)
     646        { return c ^ (d & (b ^ c)); }
     647
     648        UInt32 HH(UInt32 b, UInt32 c, UInt32 d)
     649        { return b ^ c ^ d; }
     650
     651        UInt32 II(UInt32 b, UInt32 c, UInt32 d)
     652        { return c ^ (b | ~d); }
     653
     654        UInt32 RL(UInt32 x, int n)
     655        { return (x << n) | (x >> (32 - n)); }
     656
     657        UInt32 RR(UInt32 x, int n)
     658        { return (x >> n) | (x << (32 - n)); }
     659
     660        void MD5_STEP_FF(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 m, UInt32 ac, Int32 rc)
     661        {
     662            a += (d ^ (b & (c ^ d))) + m + ac;
     663            a = (a << rc | a >> (32 - rc)) + b;
     664        }
     665
     666        void MD5_STEP_GG(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 m, UInt32 ac, Int32 rc)
     667        {
     668            a += (c ^ (d & (b ^ c))) + m + ac;
     669            a = (a << rc | a >> (32 - rc)) + b;
     670        }
     671
     672        void MD5_STEP_HH(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 m, UInt32 ac, Int32 rc)
     673        {
     674            a += (b ^ c ^ d) + m + ac;
     675            a = (a << rc | a >> (32 - rc)) + b;
     676        }
     677        void MD5_STEP_II(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 m, UInt32 ac, Int32 rc)
     678        {
     679            a += (c ^ (b | ~d)) + m + ac;
    658680            a = (a << rc | a >> (32 - rc)) + b;
    659681        }
     
    902924                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    903925
    904                         MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    905                         MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    906                         MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    907                         MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    908                         MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    909                         MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    910                         MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    911                         MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    912                         MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    913                         MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     926                        MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     927                        MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     928                        MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     929                        MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     930                        MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     931                        MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     932                        MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     933                        MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     934                        MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     935                        MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    914936
    915937                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    921943                        c = (c << 16 | c >> 16) + d;
    922944
    923                         MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    924                         MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    925                         MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    926                         MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    927                         MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    928                         MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    929                         MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    930                         MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    931                         MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    932                         MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    933                         MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    934                         MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    935                         MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     945                        MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     946                        MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     947                        MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     948                        MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     949                        MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     950                        MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     951                        MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     952                        MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     953                        MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     954                        MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     955                        MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     956                        MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     957                        MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    936958                        if (0 != ((b ^ d) & 0x80000000))
    937959                        {
     
    940962                        }
    941963
    942                         MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     964                        MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    943965                        if (0 != ((a ^ c) >> 31))
    944966                        {
     
    946968                            continue;
    947969                        }
    948                         MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     970                        MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    949971                        if (0 == ((b ^ d) >> 31))
    950972                        {
     
    952974                            continue;
    953975                        }
    954                         MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     976                        MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    955977                        if (0 != ((a ^ c) >> 31))
    956978                        {
     
    958980                            continue;
    959981                        }
    960                         MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     982                        MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    961983                        if (0 != ((b ^ d) >> 31))
    962984                        {
     
    964986                            continue;
    965987                        }
    966                         MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     988                        MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    967989                        if (0 != ((a ^ c) >> 31))
    968990                        {
     
    970992                            continue;
    971993                        }
    972                         MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     994                        MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    973995                        if (0 != ((b ^ d) >> 31))
    974996                        {
     
    976998                            continue;
    977999                        }
    978                         MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1000                        MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    9791001                        if (0 != ((a ^ c) >> 31))
    9801002                        {
     
    9821004                            continue;
    9831005                        }
    984                         MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1006                        MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    9851007                        if (0 != ((b ^ d) >> 31))
    9861008                        {
     
    9881010                            continue;
    9891011                        }
    990                         MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1012                        MD5_STEP_II( ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    9911013                        if (0 != ((a ^ c) >> 31))
    9921014                        {
     
    9941016                            continue;
    9951017                        }
    996                         MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1018                        MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    9971019                        if (0 != ((b ^ d) >> 31))
    9981020                        {
     
    10001022                            continue;
    10011023                        }
    1002                         MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1024                        MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
    10031025                        if (0 != ((a ^ c) >> 31))
    10041026                        {
     
    10061028                            continue;
    10071029                        }
    1008                         MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     1030                        MD5_STEP_II( ref b, c, d, a, block[13], 0x4e0811a1, 21);
    10091031                        if (0 == ((b ^ d) >> 31))
    10101032                        {
     
    10121034                            continue;
    10131035                        }
    1014                         MD5_STEP(II, ref  a, b, c, d, block[4], 0xf7537e82, 6);
     1036                        MD5_STEP_II( ref  a, b, c, d, block[4], 0xf7537e82, 6);
    10151037                        if (0 != ((a ^ c) >> 31))
    10161038                        {
     
    10181040                            continue;
    10191041                        }
    1020                         MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1042                        MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
    10211043                        if (0 != ((b ^ d) >> 31))
    10221044                        {
     
    10241046                            continue;
    10251047                        }
    1026                         MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1048                        MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    10271049                        if (0 != ((a ^ c) >> 31))
    10281050                        {
     
    10301052                            continue;
    10311053                        }
    1032                         MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1054                        MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    10331055
    10341056                        UInt32[] block2 = new UInt32[16];
     
    12791301                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    12801302
    1281                         MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1282                         MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1283                         MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1284                         MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1285                         MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1286                         MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1287                         MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1288                         MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1289                         MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1290                         MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1303                        MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1304                        MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     1305                        MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1306                        MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     1307                        MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1308                        MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1309                        MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     1310                        MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1311                        MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     1312                        MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    12911313
    12921314                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    12981320                        c = (c << 16 | c >> 16) + d;
    12991321
    1300                         MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1301                         MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1302                         MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1303                         MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1304                         MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1305                         MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1306                         MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1307                         MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1308                         MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1309                         MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1310                         MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1311                         MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1312                         MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1322                        MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     1323                        MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     1324                        MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1325                        MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1326                        MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1327                        MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1328                        MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1329                        MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1330                        MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     1331                        MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1332                        MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1333                        MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1334                        MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    13131335                        if (0 != ((b ^ d) & 0x80000000))
    13141336                        {
     
    13171339                        }
    13181340
    1319                         MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1341                        MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    13201342                        if (0 != ((a ^ c) >> 31))
    13211343                        {
     
    13231345                            continue;
    13241346                        }
    1325                         MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1347                        MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    13261348                        if (0 == ((b ^ d) >> 31))
    13271349                        {
     
    13291351                            continue;
    13301352                        }
    1331                         MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1353                        MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    13321354                        if (0 != ((a ^ c) >> 31))
    13331355                        {
     
    13351357                            continue;
    13361358                        }
    1337                         MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1359                        MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    13381360                        if (0 != ((b ^ d) >> 31))
    13391361                        {
     
    13411363                            continue;
    13421364                        }
    1343                         MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1365                        MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    13441366                        if (0 != ((a ^ c) >> 31))
    13451367                        {
     
    13471369                            continue;
    13481370                        }
    1349                         MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1371                        MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    13501372                        if (0 != ((b ^ d) >> 31))
    13511373                        {
     
    13531375                            continue;
    13541376                        }
    1355                         MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1377                        MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    13561378                        if (0 != ((a ^ c) >> 31))
    13571379                        {
     
    13591381                            continue;
    13601382                        }
    1361                         MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1383                        MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    13621384                        if (0 != ((b ^ d) >> 31))
    13631385                        {
     
    13651387                            continue;
    13661388                        }
    1367                         MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1389                        MD5_STEP_II( ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    13681390                        if (0 != ((a ^ c) >> 31))
    13691391                        {
     
    13711393                            continue;
    13721394                        }
    1373                         MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1395                        MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    13741396                        if (0 != ((b ^ d) >> 31))
    13751397                        {
     
    13771399                            continue;
    13781400                        }
    1379                         MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1401                        MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
    13801402                        if (0 != ((a ^ c) >> 31))
    13811403                        {
     
    13831405                            continue;
    13841406                        }
    1385                         MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     1407                        MD5_STEP_II( ref b, c, d, a, block[13], 0x4e0811a1, 21);
    13861408                        if (0 == ((b ^ d) >> 31))
    13871409                        {
     
    13891411                            continue;
    13901412                        }
    1391                         MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     1413                        MD5_STEP_II( ref a, b, c, d, block[4], 0xf7537e82, 6);
    13921414                        if (0 != ((a ^ c) >> 31))
    13931415                        {
     
    13951417                            continue;
    13961418                        }
    1397                         MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1419                        MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
    13981420                        if (0 != ((b ^ d) >> 31))
    13991421                        {
     
    14011423                            continue;
    14021424                        }
    1403                         MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1425                        MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    14041426                        if (0 != ((a ^ c) >> 31))
    14051427                        {
     
    14071429                            continue;
    14081430                        }
    1409                         MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1431                        MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    14101432
    14111433                        UInt32[] block2 = new UInt32[16];
     
    16121634                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    16131635
    1614                         MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1615                         MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1616                         MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1617                         MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1618                         MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1619                         MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1620                         MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1621                         MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1622                         MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1623                         MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1636                        MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1637                        MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     1638                        MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1639                        MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     1640                        MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1641                        MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1642                        MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     1643                        MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1644                        MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     1645                        MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    16241646
    16251647                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    16281650                        c = (c << 16 | c >> 16) + d;
    16291651
    1630                         MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1631                         MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1632                         MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1633                         MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1634                         MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1635                         MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1636                         MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1637                         MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1638                         MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1639                         MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1640                         MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1641                         MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1642                         MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1652                        MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     1653                        MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     1654                        MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1655                        MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1656                        MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1657                        MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1658                        MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1659                        MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1660                        MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     1661                        MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1662                        MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1663                        MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1664                        MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    16431665                        if (0 != ((b ^ d) & 0x80000000))
    16441666                            { LogReturn(14); continue; }
    16451667
    1646                         MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1668                        MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    16471669                        if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    1648                         MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1670                        MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    16491671                        if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    1650                         MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1672                        MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    16511673                        if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    1652                         MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1674                        MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    16531675                        if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    1654                         MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1676                        MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    16551677                        if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    1656                         MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1678                        MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    16571679                        if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    1658                         MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1680                        MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    16591681                        if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    1660                         MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1682                        MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    16611683                        if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    1662                         MD5_STEP(II, ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
     1684                        MD5_STEP_II( ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
    16631685                        if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    1664                         MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1686                        MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    16651687                        if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    1666                         MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1688                        MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
    16671689                        if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    1668                         MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     1690                        MD5_STEP_II( ref b, c, d, a, block[13], 0x4e0811a1, 21);
    16691691                        if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    1670                         MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     1692                        MD5_STEP_II( ref a, b, c, d, block[4], 0xf7537e82, 6);
    16711693                        if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    1672                         MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1694                        MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
    16731695                        if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    1674                         MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1696                        MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    16751697                        if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    1676                         MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1698                        MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    16771699
    16781700                        //std::cout << "." << std::flush;
     
    18821904                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    18831905
    1884                         MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1885                         MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1886                         MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1887                         MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1888                         MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1889                         MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1890                         MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1891                         MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1892                         MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1893                         MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1906                        MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1907                        MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     1908                        MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1909                        MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     1910                        MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1911                        MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1912                        MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     1913                        MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1914                        MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     1915                        MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    18941916
    18951917                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    18981920                        c = (c << 16 | c >> 16) + d;
    18991921
    1900                         MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1901                         MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1902                         MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1903                         MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1904                         MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1905                         MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1906                         MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1907                         MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1908                         MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1909                         MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1910                         MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1911                         MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1912                         MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1922                        MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     1923                        MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     1924                        MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1925                        MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1926                        MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1927                        MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1928                        MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1929                        MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1930                        MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     1931                        MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1932                        MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1933                        MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1934                        MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    19131935                        if (0 != ((b ^ d) & 0x80000000))
    19141936                            { LogReturn(14); continue; }
    19151937
    1916                         MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1938                        MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    19171939                        if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    1918                         MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1940                        MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    19191941                        if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    1920                         MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1942                        MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    19211943                        if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    1922                         MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1944                        MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    19231945                        if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    1924                         MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1946                        MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    19251947                        if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    1926                         MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1948                        MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    19271949                        if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    1928                         MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1950                        MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    19291951                        if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    1930                         MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1952                        MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    19311953                        if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    1932                         MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1954                        MD5_STEP_II( ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    19331955                        if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    1934                         MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1956                        MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    19351957                        if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    1936                         MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1958                        MD5_STEP_II( ref c, d, a, b, block[6], 0xa3014314, 15);
    19371959                        if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    1938                         MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
     1960                        MD5_STEP_II( ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    19391961                        if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    1940                         MD5_STEP(II, ref  a, b, c, d, block[4], 0xf7537e82, 6);
     1962                        MD5_STEP_II( ref  a, b, c, d, block[4], 0xf7537e82, 6);
    19411963                        if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    1942                         MD5_STEP(II, ref  d, a, b, c, block[11], 0xbd3af235, 10);
     1964                        MD5_STEP_II( ref  d, a, b, c, block[11], 0xbd3af235, 10);
    19431965                        if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    1944                         MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1966                        MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    19451967                        if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    1946                         MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1968                        MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    19471969
    19481970                        //std::cout << "." << std::flush;
     
    21732195                            MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    21742196
    2175                             MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    2176                             MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    2177                             MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    2178                             MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    2179                             MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    2180                             MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    2181                             MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    2182                             MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    2183                             MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    2184                             MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     2197                            MD5_STEP_GG( ref a, b, c, d, block[9], 0x21e1cde6, 5);
     2198                            MD5_STEP_GG( ref d, a, b, c, block[14], 0xc33707d6, 9);
     2199                            MD5_STEP_GG( ref c, d, a, b, block[3], 0xf4d50d87, 14);
     2200                            MD5_STEP_GG( ref b, c, d, a, block[8], 0x455a14ed, 20);
     2201                            MD5_STEP_GG( ref a, b, c, d, block[13], 0xa9e3e905, 5);
     2202                            MD5_STEP_GG( ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     2203                            MD5_STEP_GG( ref c, d, a, b, block[7], 0x676f02d9, 14);
     2204                            MD5_STEP_GG( ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     2205                            MD5_STEP_HH( ref a, b, c, d, block[5], 0xfffa3942, 4);
     2206                            MD5_STEP_HH( ref d, a, b, c, block[8], 0x8771f681, 11);
    21852207
    21862208                            c += HH(d, a, b) + block[11] + 0x6d9d6122;
     
    21892211                            c = (c << 16 | c >> 16) + d;
    21902212
    2191                             MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    2192                             MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    2193                             MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    2194                             MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    2195                             MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    2196                             MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    2197                             MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    2198                             MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    2199                             MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    2200                             MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    2201                             MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    2202                             MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    2203                             MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     2213                            MD5_STEP_HH( ref b, c, d, a, block[14], 0xfde5380c, 23);
     2214                            MD5_STEP_HH( ref a, b, c, d, block[1], 0xa4beea44, 4);
     2215                            MD5_STEP_HH( ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     2216                            MD5_STEP_HH( ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     2217                            MD5_STEP_HH( ref b, c, d, a, block[10], 0xbebfbc70, 23);
     2218                            MD5_STEP_HH( ref a, b, c, d, block[13], 0x289b7ec6, 4);
     2219                            MD5_STEP_HH( ref d, a, b, c, block[0], 0xeaa127fa, 11);
     2220                            MD5_STEP_HH( ref c, d, a, b, block[3], 0xd4ef3085, 16);
     2221                            MD5_STEP_HH( ref b, c, d, a, block[6], 0x04881d05, 23);
     2222                            MD5_STEP_HH( ref a, b, c, d, block[9], 0xd9d4d039, 4);
     2223                            MD5_STEP_HH( ref d, a, b, c, block[12], 0xe6db99e5, 11);
     2224                            MD5_STEP_HH( ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     2225                            MD5_STEP_HH( ref b, c, d, a, block[2], 0xc4ac5665, 23);
    22042226                            if (0 != ((b ^ d) & 0x80000000))
    22052227                                { LogReturn(14); continue; }
    22062228
    2207                             MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     2229                            MD5_STEP_II( ref a, b, c, d, block[0], 0xf4292244, 6);
    22082230                            if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    2209                             MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     2231                            MD5_STEP_II( ref d, a, b, c, block[7], 0x432aff97, 10);
    22102232                            if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    2211                             MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     2233                            MD5_STEP_II( ref c, d, a, b, block[14], 0xab9423a7, 15);
    22122234                            if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    2213                             MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     2235                            MD5_STEP_II( ref b, c, d, a, block[5], 0xfc93a039, 21);
    22142236                            if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    2215                             MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     2237                            MD5_STEP_II( ref a, b, c, d, block[12], 0x655b59c3, 6);
    22162238                            if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    2217                             MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     2239                            MD5_STEP_II( ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    22182240                            if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    2219                             MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     2241                            MD5_STEP_II( ref c, d, a, b, block[10], 0xffeff47d, 15);
    22202242                            if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    2221                             MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     2243                            MD5_STEP_II( ref b, c, d, a, block[1], 0x85845dd1, 21);
    22222244                            if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    2223                             MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     2245                            MD5_STEP_II( ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    22242246                            if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    2225                             MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     2247                            MD5_STEP_II( ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    22262248                            if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    2227                             MD5_STEP(II, ref  c, d, a, b, block[6], 0xa3014314, 15);
     2249                            MD5_STEP_II( ref  c, d, a, b, block[6], 0xa3014314, 15);
    22282250                            if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    2229                             MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
     2251                            MD5_STEP_II( ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    22302252                            if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    2231                             MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     2253                            MD5_STEP_II( ref a, b, c, d, block[4], 0xf7537e82, 6);
    22322254                            if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    2233                             MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     2255                            MD5_STEP_II( ref d, a, b, c, block[11], 0xbd3af235, 10);
    22342256                            if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    2235                             MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     2257                            MD5_STEP_II( ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    22362258                            if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    2237                             MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     2259                            MD5_STEP_II( ref b, c, d, a, block[9], 0xeb86d391, 21);
    22382260
    22392261                            //std::cout << "." << std::flush;
Note: See TracChangeset for help on using the changeset viewer.