local md5 = {
    _VERSION     = "md5.lua 1.1.0",
    _DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)",
    _URL         = "https://github.com/kikito/md5.lua",
    _LICENSE     = [[
      MIT LICENSE
      Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software
      Permission is hereby granted, free of charge, to any person obtaining a
      copy of this software and associated documentation files (the
      "Software"), to deal in the Software without restriction, including
      without limitation the rights to use, copy, modify, merge, publish,
      distribute, sublicense, and/or sell copies of the Software, and to
      permit persons to whom the Software is furnished to do so, subject to
      the following conditions:
      The above copyright notice and this permission notice shall be included
      in all copies or substantial portions of the Software.
      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    ]]
  }
  
  -- bit lib implementions
  
  local char, byte, format, rep, sub =
    string.char, string.byte, string.format, string.rep, string.sub
  local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift
  
  local ok, bit = pcall(require, 'bit')
  if ok then
    bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift
  else
    ok, bit = pcall(require, 'bit32')
  
    if ok then
  
      bit_not = bit.bnot
  
      local tobit = function(n)
        return n <= 0x7fffffff and n or -(bit_not(n) + 1)
      end
  
      local normalize = function(f)
        return function(a,b) return tobit(f(tobit(a), tobit(b))) end
      end
  
      bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor)
      bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift)
  
    else
  
      local function tbl2number(tbl)
        local result = 0
        local power = 1
        for i = 1, #tbl do
          result = result + tbl[i] * power
          power = power * 2
        end
        return result
      end
  
      local function expand(t1, t2)
        local big, small = t1, t2
        if(#big < #small) then
          big, small = small, big
        end
        -- expand small
        for i = #small + 1, #big do
          small[i] = 0
        end
      end
  
      local to_bits -- needs to be declared before bit_not
  
      bit_not = function(n)
        local tbl = to_bits(n)
        local size = math.max(#tbl, 32)
        for i = 1, size do
          if(tbl[i] == 1) then
            tbl[i] = 0
          else
            tbl[i] = 1
          end
        end
        return tbl2number(tbl)
      end
  
      -- defined as local above
      to_bits = function (n)
        if(n < 0) then
          -- negative
          return to_bits(bit_not(math.abs(n)) + 1)
        end
        -- to bits table
        local tbl = {}
        local cnt = 1
        local last
        while n > 0 do
          last      = n % 2
          tbl[cnt]  = last
          n         = (n-last)/2
          cnt       = cnt + 1
        end
  
        return tbl
      end
  
      bit_or = function(m, n)
        local tbl_m = to_bits(m)
        local tbl_n = to_bits(n)
        expand(tbl_m, tbl_n)
  
        local tbl = {}
        for i = 1, #tbl_m do
          if(tbl_m[i]== 0 and tbl_n[i] == 0) then
            tbl[i] = 0
          else
            tbl[i] = 1
          end
        end
  
        return tbl2number(tbl)
      end
  
      bit_and = function(m, n)
        local tbl_m = to_bits(m)
        local tbl_n = to_bits(n)
        expand(tbl_m, tbl_n)
  
        local tbl = {}
        for i = 1, #tbl_m do
          if(tbl_m[i]== 0 or tbl_n[i] == 0) then
            tbl[i] = 0
          else
            tbl[i] = 1
          end
        end
  
        return tbl2number(tbl)
      end
  
      bit_xor = function(m, n)
        local tbl_m = to_bits(m)
        local tbl_n = to_bits(n)
        expand(tbl_m, tbl_n)
  
        local tbl = {}
        for i = 1, #tbl_m do
          if(tbl_m[i] ~= tbl_n[i]) then
            tbl[i] = 1
          else
            tbl[i] = 0
          end
        end
  
        return tbl2number(tbl)
      end
  
      bit_rshift = function(n, bits)
        local high_bit = 0
        if(n < 0) then
          -- negative
          n = bit_not(math.abs(n)) + 1
          high_bit = 0x80000000
        end
  
        local floor = math.floor
  
        for i=1, bits do
          n = n/2
          n = bit_or(floor(n), high_bit)
        end
        return floor(n)
      end
  
      bit_lshift = function(n, bits)
        if(n < 0) then
          -- negative
          n = bit_not(math.abs(n)) + 1
        end
  
        for i=1, bits do
          n = n*2
        end
        return bit_and(n, 0xFFFFFFFF)
      end
    end
  end
  
  -- convert little-endian 32-bit int to a 4-char string
  local function lei2str(i)
    local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
    return f(0)..f(8)..f(16)..f(24)
  end
  
  -- convert raw string to big-endian int
  local function str2bei(s)
    local v=0
    for i=1, #s do
      v = v * 256 + byte(s, i)
    end
    return v
  end
  
  -- convert raw string to little-endian int
  local function str2lei(s)
    local v=0
    for i = #s,1,-1 do
      v = v*256 + byte(s, i)
    end
    return v
  end
  
  -- cut up a string in little-endian ints of given size
  local function cut_le_str(s,...)
    local o, r = 1, {}
    local args = {...}
    for i=1, #args do
      table.insert(r, str2lei(sub(s, o, o + args[i] - 1)))
      o = o + args[i]
    end
    return r
  end
  
  local swap = function (w) return str2bei(lei2str(w)) end
  
  -- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
  -- 10/02/2001 jcw@equi4.com
  
  local CONSTS = {
    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
    0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
    0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
    0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
    0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
    0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
    0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
    0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
  }
  
  local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
  local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
  local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
  local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
  local z=function (ff,a,b,c,d,x,s,ac)
    a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF)
    -- be *very* careful that left shift does not cause rounding!
    return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b
  end
  
  local function transform(A,B,C,D,X)
    local a,b,c,d=A,B,C,D
    local t=CONSTS
  
    a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
    d=z(f,d,a,b,c,X[ 1],12,t[ 2])
    c=z(f,c,d,a,b,X[ 2],17,t[ 3])
    b=z(f,b,c,d,a,X[ 3],22,t[ 4])
    a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
    d=z(f,d,a,b,c,X[ 5],12,t[ 6])
    c=z(f,c,d,a,b,X[ 6],17,t[ 7])
    b=z(f,b,c,d,a,X[ 7],22,t[ 8])
    a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
    d=z(f,d,a,b,c,X[ 9],12,t[10])
    c=z(f,c,d,a,b,X[10],17,t[11])
    b=z(f,b,c,d,a,X[11],22,t[12])
    a=z(f,a,b,c,d,X[12], 7,t[13])
    d=z(f,d,a,b,c,X[13],12,t[14])
    c=z(f,c,d,a,b,X[14],17,t[15])
    b=z(f,b,c,d,a,X[15],22,t[16])
  
    a=z(g,a,b,c,d,X[ 1], 5,t[17])
    d=z(g,d,a,b,c,X[ 6], 9,t[18])
    c=z(g,c,d,a,b,X[11],14,t[19])
    b=z(g,b,c,d,a,X[ 0],20,t[20])
    a=z(g,a,b,c,d,X[ 5], 5,t[21])
    d=z(g,d,a,b,c,X[10], 9,t[22])
    c=z(g,c,d,a,b,X[15],14,t[23])
    b=z(g,b,c,d,a,X[ 4],20,t[24])
    a=z(g,a,b,c,d,X[ 9], 5,t[25])
    d=z(g,d,a,b,c,X[14], 9,t[26])
    c=z(g,c,d,a,b,X[ 3],14,t[27])
    b=z(g,b,c,d,a,X[ 8],20,t[28])
    a=z(g,a,b,c,d,X[13], 5,t[29])
    d=z(g,d,a,b,c,X[ 2], 9,t[30])
    c=z(g,c,d,a,b,X[ 7],14,t[31])
    b=z(g,b,c,d,a,X[12],20,t[32])
  
    a=z(h,a,b,c,d,X[ 5], 4,t[33])
    d=z(h,d,a,b,c,X[ 8],11,t[34])
    c=z(h,c,d,a,b,X[11],16,t[35])
    b=z(h,b,c,d,a,X[14],23,t[36])
    a=z(h,a,b,c,d,X[ 1], 4,t[37])
    d=z(h,d,a,b,c,X[ 4],11,t[38])
    c=z(h,c,d,a,b,X[ 7],16,t[39])
    b=z(h,b,c,d,a,X[10],23,t[40])
    a=z(h,a,b,c,d,X[13], 4,t[41])
    d=z(h,d,a,b,c,X[ 0],11,t[42])
    c=z(h,c,d,a,b,X[ 3],16,t[43])
    b=z(h,b,c,d,a,X[ 6],23,t[44])
    a=z(h,a,b,c,d,X[ 9], 4,t[45])
    d=z(h,d,a,b,c,X[12],11,t[46])
    c=z(h,c,d,a,b,X[15],16,t[47])
    b=z(h,b,c,d,a,X[ 2],23,t[48])
  
    a=z(i,a,b,c,d,X[ 0], 6,t[49])
    d=z(i,d,a,b,c,X[ 7],10,t[50])
    c=z(i,c,d,a,b,X[14],15,t[51])
    b=z(i,b,c,d,a,X[ 5],21,t[52])
    a=z(i,a,b,c,d,X[12], 6,t[53])
    d=z(i,d,a,b,c,X[ 3],10,t[54])
    c=z(i,c,d,a,b,X[10],15,t[55])
    b=z(i,b,c,d,a,X[ 1],21,t[56])
    a=z(i,a,b,c,d,X[ 8], 6,t[57])
    d=z(i,d,a,b,c,X[15],10,t[58])
    c=z(i,c,d,a,b,X[ 6],15,t[59])
    b=z(i,b,c,d,a,X[13],21,t[60])
    a=z(i,a,b,c,d,X[ 4], 6,t[61])
    d=z(i,d,a,b,c,X[11],10,t[62])
    c=z(i,c,d,a,b,X[ 2],15,t[63])
    b=z(i,b,c,d,a,X[ 9],21,t[64])
  
    return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF),
           bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF)
  end
  
  ----------------------------------------------------------------
  
  local function md5_update(self, s)
    self.pos = self.pos + #s
    s = self.buf .. s
    for ii = 1, #s - 63, 64 do
      local X = cut_le_str(sub(s,ii,ii+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
      assert(#X == 16)
      X[0] = table.remove(X,1) -- zero based!
      self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X)
    end
    self.buf = sub(s, math.floor(#s/64)*64 + 1, #s)
    return self
  end
  
  local function md5_finish(self)
    local msgLen = self.pos
    local padLen = 56 - msgLen % 64
  
    if msgLen % 64 > 56 then padLen = padLen + 64 end
  
    if padLen == 0 then padLen = 64 end
  
    local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000))
    md5_update(self, s)
  
    assert(self.pos % 64 == 0)
    return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d)
  end
  
  ----------------------------------------------------------------
  
  function md5.new()
    return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68],
             pos = 0,
             buf = '',
             update = md5_update,
             finish = md5_finish }
  end
  
  function md5.tohex(s)
    return format("%08x%08x%08x%08x", str2bei(sub(s, 1, 4)), str2bei(sub(s, 5, 8)), str2bei(sub(s, 9, 12)), str2bei(sub(s, 13, 16)))
  end
  
  function md5.sum(s)
    return md5.new():update(s):finish()
  end
  
  function md5.sumhexa(s)
    return md5.tohex(md5.sum(s))
  end
  
  return md5