rem: md5_process_block (buffer, len, ctx) const void *buffer; size_t len; struct md5_ctx *ctx;
add: md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
context: md5_process_block (buffer, len, ctx)     const void *buffer;     size_t len;     struct md5_ctx *ctx;{  md5_uint32 correct_words[16];  const md5_uint32 *words = buffer;  size_t nwords = len / sizeof (md5_uint32);  const md5_uint32 *endp = words + nwords;  md5_uint32 A = ctx->A;  md5_uint32 B = ctx->B;  md5_uint32 C = ctx->C;  md5_uint32 D = ctx->D;  /* First increment the byte count.  RFC 1321 specifies the possible     length of the file up to 2^64 bits.  Here we only compute the     number of bytes.  Do a double word increment.  */  ctx->total[0] += len;  if (ctx->total[0] < len)    ++ctx->total[1];  /* Process all bytes in the buffer with 64 bytes in each round of     the loop.  */  while (words < endp)    {      md5_uint32 *cwp = correct_words;      md5_uint32 A_save = A;      md5_uint32 B_save = B;      md5_uint32 C_save = C;      md5_uint32 D_save = D;      /* First round: using the given function, the context and a constant	 the next context is computed.  Because the algorithms processing	 unit is a 32-bit word and it is determined to work on words in	 little endian byte order we perhaps have to change the byte order	 before the computation.  To reduce the work for the next steps	 we store the swapped words in the array CORRECT_WORDS.  */#define OP(a, b, c, d, s, T)						\      do								\        {								\	  a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;		\	  ++words;							\	  a = rol (a, s);						\	  a += b;							\        }								\      while (0)      /* Before we start, one word to the strange constants.	 They are defined in RFC 1321 as	 T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64, or	 perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'       */      /* Round 1.  */      OP (A, B, C, D,  7, 0xd76aa478);      OP (D, A, B, C, 12, 0xe8c7b756);      OP (C, D, A, B, 17, 0x242070db);      OP (B, C, D, A, 22, 0xc1bdceee);      OP (A, B, C, D,  7, 0xf57c0faf);      OP (D, A, B, C, 12, 0x4787c62a);      OP (C, D, A, B, 17, 0xa8304613);      OP (B, C, D, A, 22, 0xfd469501);      OP (A, B, C, D,  7, 0x698098d8);      OP (D, A, B, C, 12, 0x8b44f7af);      OP (C, D, A, B, 17, 0xffff5bb1);      OP (B, C, D, A, 22, 0x895cd7be);      OP (A, B, C, D,  7, 0x6b901122);      OP (D, A, B, C, 12, 0xfd987193);      OP (C, D, A, B, 17, 0xa679438e);      OP (B, C, D, A, 22, 0x49b40821);      /* For the second to fourth round we have the possibly swapped words	 in CORRECT_WORDS.  Redefine the macro to take an additional first	 argument specifying the function to use.  */#undef OP#define OP(f, a, b, c, d, k, s, T)					\      do 								\	{								\	  a += f (b, c, d) + correct_words[k] + T;			\	  a = rol (a, s);						\	  a += b;							\	}								\      while (0)      /* Round 2.  */      OP (FG, A, B, C, D,  1,  5, 0xf61e2562);      OP (FG, D, A, B, C,  6,  9, 0xc040b340);      OP (FG, C, D, A, B, 11, 14, 0x265e5a51);      OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);      OP (FG, A, B, C, D,  5,  5, 0xd62f105d);      OP (FG, D, A, B, C, 10,  9, 0x02441453);      OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);      OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);      OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);      OP (FG, D, A, B, C, 14,  9, 0xc33707d6);      OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);      OP (FG, B, C, D, A,  8, 20, 0x455a14ed);      OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);      OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);      OP (FG, C, D, A, B,  7, 14, 0x676f02d9);      OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);      /* Round 3.  */      OP (FH, A, B, C, D,  5,  4, 0xfffa3942);      OP (FH, D, A, B, C,  8, 11, 0x8771f681);      OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);      OP (FH, B, C, D, A, 14, 23, 0xfde5380c);      OP (FH, A, B, C, D,  1,  4, 0xa4beea44);      OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);      OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);      OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);      OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);      OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);      OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);      OP (FH, B, C, D, A,  6, 23, 0x04881d05);      OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);      OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);      OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);      OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);      /* Round 4.  */      OP (FI, A, B, C, D,  0,  6, 0xf4292244);      OP (FI, D, A, B, C,  7, 10, 0x432aff97);      OP (FI, C, D, A, B, 14, 15, 0xab9423a7);      OP (FI, B, C, D, A,  5, 21, 0xfc93a039);      OP (FI, A, B, C, D, 12,  6, 0x655b59c3);      OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);      OP (FI, C, D, A, B, 10, 15, 0xffeff47d);      OP (FI, B, C, D, A,  1, 21, 0x85845dd1);      OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);      OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);      OP (FI, C, D, A, B,  6, 15, 0xa3014314);      OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);      OP (FI, A, B, C, D,  4,  6, 0xf7537e82);      OP (FI, D, A, B, C, 11, 10, 0xbd3af235);      OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);      OP (FI, B, C, D, A,  9, 21, 0xeb86d391);      /* Add the starting values of the context.  */      A += A_save;      B += B_save;      C += C_save;      D += D_save;    }  /* Put checksum in context given as argument.  */  ctx->A = A;  ctx->B = B;  ctx->C = C;  ctx->D = D;}