• Add integers,wrapping at 2^32. This uses 16-bit operations internally
• to work around bugs in some JS interpreters.
  */
  function safe_add(x,y)
  {
  var lsw = (x & 0xFFFF) + (y & 0xFFFF)
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
  return (msw << 16) | (lsw & 0xFFFF)
  }

/*

• Bitwise rotate a 32-bit number to the left.
  */
  function rol(num,cnt)
  {
  return (num << cnt) | (num >>> (32 - cnt))
  }

/*

• These functions implement the four basic operations the algorithm uses.
  */
  function cmn(q,a,b,x,s,t)
  {
  return safe_add(rol(safe_add(safe_add(a,q),safe_add(x,t)),s),b)
  }
  function ff(a,c,d,t)
  {
  return cmn((b & c) | ((~b) & d),t)
  }
  function gg(a,t)
  {
  return cmn((b & d) | (c & (~d)),t)
  }
  function hh(a,t)
  {
  return cmn(b ^ c ^ d,t)
  }
  function ii(a,t)
  {
  return cmn(c ^ (b | (~d)),t)
  }

/*

• Calculate the MD5 of an array of little-endian words,producing an array
• of little-endian words.
  */
  function coreMD5(x)
  {
  var a = 1732584193
  var b = -271733879
  var c = -1732584194
  var d = 271733878

for(var i = 0; i < x.length; i += 16)
{
var olda = a
var oldb = b
var oldc = c
var oldd = d

a = ff(a,x[i+ 0],7,-680876936)
d = ff(d,x[i+ 1],12,-389564586)
c = ff(c,x[i+ 2],17,606105819)
b = ff(b,x[i+ 3],22,-1044525330)
a = ff(a,x[i+ 4],-176418897)
d = ff(d,x[i+ 5],1200080426)
c = ff(c,x[i+ 6],-1473231341)
b = ff(b,x[i+ 7],-45705983)
a = ff(a,x[i+ 8],1770035416)
d = ff(d,x[i+ 9],-1958414417)
c = ff(c,x[i+10],-42063)
b = ff(b,x[i+11],-1990404162)
a = ff(a,x[i+12],1804603682)
d = ff(d,x[i+13],-40341101)
c = ff(c,x[i+14],-1502002290)
b = ff(b,x[i+15],1236535329)

a = gg(a,5,-165796510)
d = gg(d,9,-1069501632)
c = gg(c,14,643717713)
b = gg(b,20,-373897302)
a = gg(a,-701558691)
d = gg(d,38016083)
c = gg(c,-660478335)
b = gg(b,-405537848)
a = gg(a,568446438)
d = gg(d,-1019803690)
c = gg(c,-187363961)
b = gg(b,1163531501)
a = gg(a,-1444681467)
d = gg(d,-51403784)
c = gg(c,1735328473)
b = gg(b,-1926607734)

a = hh(a,4,-378558)
d = hh(d,11,-2022574463)
c = hh(c,16,1839030562)
b = hh(b,23,-35309556)
a = hh(a,-1530992060)
d = hh(d,1272893353)
c = hh(c,-155497632)
b = hh(b,-1094730640)
a = hh(a,681279174)
d = hh(d,-358537222)
c = hh(c,-722521979)
b = hh(b,76029189)
a = hh(a,-640364487)
d = hh(d,-421815835)
c = hh(c,530742520)
b = hh(b,-995338651)

a = ii(a,6,-198630844)
d = ii(d,10,1126891415)
c = ii(c,15,-1416354905)
b = ii(b,21,-57434055)
a = ii(a,1700485571)
d = ii(d,-1894986606)
c = ii(c,-1051523)
b = ii(b,-2054922799)
a = ii(a,1873313359)
d = ii(d,-30611744)
c = ii(c,-1560198380)
b = ii(b,1309151649)
a = ii(a,-145523070)
d = ii(d,-1120210379)
c = ii(c,718787259)
b = ii(b,-343485551)

a = safe_add(a,olda)
b = safe_add(b,oldb)
c = safe_add(c,oldc)
d = safe_add(d,oldd)
}
return [a,d]
}

/*

• Convert an array of little-endian words to a hex string.
  /
  function binl2hex(binarray)
  {
  var hex_tab = "0123456789abcdef"
  var str = ""
  for(var i = 0; i < binarray.length 4; i++)
  {
  str += hex_tab.charAt((binarray[i>>2] >> ((i%4)8+4)) & 0xF) +
  hex_tab.charAt((binarray[i>>2] >> ((i%4)8)) & 0xF)
  }
  return str
  }

/*

• Convert an array of little-endian words to a base64 encoded string.
  /
  function binl2b64(binarray)
  {
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
  var str = ""
  for(var i = 0; i < binarray.length 32; i += 6)
  {
  str += tab.charAt(((binarray[i>>5] << (i%32)) & 0x3F) |
  ((binarray[i>>5+1] >> (32-i%32)) & 0x3F))
  }
  return str
  }

/*

• Convert an 8-bit character string to a sequence of 16-word blocks,stored
• as an array,and append appropriate padding for MD4/5 calculation.
• If any of the characters are >255,the high byte is silently ignored.
  /
  function str2binl(str)
  {
  var nblk = ((str.length + 8) >> 6) + 1 // number of 16-word blocks
  var blks = new Array(nblk 16)
  for(var i = 0; i < nblk 16; i++) blks[i] = 0
  for(var i = 0; i < str.length; i++)
  blks[i>>2] |= (str.charCodeAt(i) & 0xFF) << ((i%4) 8)
  blks[i>>2] |= 0x80 << ((i%4) 8)
  blks[nblk16-2] = str.length * 8
  return blks
  }

/*

• Convert a wide-character string to a sequence of 16-word blocks,stored as
• an array,and append appropriate padding for MD4/5 calculation.
  /
  function strw2binl(str)
  {
  var nblk = ((str.length + 4) >> 5) + 1 // number of 16-word blocks
  var blks = new Array(nblk 16)
  for(var i = 0; i < nblk 16; i++) blks[i] = 0
  for(var i = 0; i < str.length; i++)
  blks[i>>1] |= str.charCodeAt(i) << ((i%2) 16)
  blks[i>>1] |= 0x80 << ((i%2) 16)
  blks[nblk16-2] = str.length * 16
  return blks
  }

/*

• External interface
  /
  function hexMD5 (str) { return binl2hex(coreMD5( str2binl(str))) }
  function hexMD5w(str) { return binl2hex(coreMD5(strw2binl(str))) }
  function b64MD5 (str) { return binl2b64(coreMD5( str2binl(str))) }
  function b64MD5w(str) { return binl2b64(coreMD5(strw2binl(str))) }
  / Backward compatibility */
  function calcMD5(str) { return binl2hex(coreMD5( str2binl(str))) }
  module.exports = {
  hexMD5: hexMD5
  }