//Note: All variables are unsigned 32 bit and wrap modulo 2^32 when calculating
  

  var int[64] r, k
  

  

  //r specifies the per-round shift amounts
  

  r[ 0..15] := {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22}
  

  r[16..31] := {5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20}
  

  r[32..47] := {4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23}
  

  r[48..63] := {6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21}
  

  

  //Use binary integer part of the sines of integers (Radians) as constants:
  

  for i from 0 to 63
  

  k[i] := floor(abs(sin(i + 1)) × (2 pow 32))
  

  end for
  

  //(Or just use the following table):
  

  k[ 0.. 3] := { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee }
  

  k[ 4.. 7] := { 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 }
  

  k[ 8..11] := { 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be }
  

  k[12..15] := { 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 }
  

  k[16..19] := { 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa }
  

  k[20..23] := { 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 }
  

  k[24..27] := { 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed }
  

  k[28..31] := { 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a }
  

  k[32..35] := { 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c }
  

  k[36..39] := { 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 }
  

  k[40..43] := { 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 }
  

  k[44..47] := { 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 }
  

  k[48..51] := { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 }
  

  k[52..55] := { 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 }
  

  k[56..59] := { 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 }
  

  k[60..63] := { 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 }
  

  

  //Initialize variables:
  

  var int h0 := 0x67452301   //A
  

  var int h1 := 0xefcdab89   //B
  

  var int h2 := 0x98badcfe   //C
  

  var int h3 := 0x10325476   //D
  

  

  //Pre-processing: adding a single 1 bit
  

  append "1" bit to message
  

  /* Notice: the input bytes are considered as bits strings,
  

  where the first bit is the most significant bit of the byte.[37]
  

  

  //Pre-processing: padding with zeros
  

  append "0" bit until message length in bit ≡ 448 (mod 512)
  

  append length mod (2 pow 64) to message
  

  

  //Process the message in successive 512-bit chunks:
  

  for each 512-bit chunk of message
  

  break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15
  

  //Initialize hash value for this chunk:
  

  var int a := h0
  

  var int b := h1
  

  var int c := h2
  

  var int d := h3
  

  //Main loop:
  

  for i from 0 to 63
  

  if 0 ≤ i ≤ 15 then
  

  f := (b and c) or ((not b) and d)
  

  g := i
  

  else if 16 ≤ i ≤ 31
  

  f := (d and b) or ((not d) and c)
  

  g := (5×i + 1) mod 16
  

  else if 32 ≤ i ≤ 47
  

  f := b xor c xor d
  

  g := (3×i + 5) mod 16
  

  else if 48 ≤ i ≤ 63
  

  f := c xor (b or (not d))
  

  g := (7×i) mod 16
  

  temp := d
  

  d := c
  

  c := b
  

  b := b + leftrotate((a + f + k[i] + w[g]) , r[i])
  

  a := temp
  

  end for
  

  //Add this chunk's hash to result so far:
  

  h0 := h0 + a
  

  h1 := h1 + b
  

  h2 := h2 + c
  

  h3 := h3 + d
  

  end for
  

  

  var char digest[16] := h0 append h1 append h2 append h3 //(Output is in little-endian)
  

  

  //leftrotate function definition
  

  leftrotate (x, c)
  

  return (x << c) binary or (x >> (32-c));