const
  p0 = 0xa0761d6478bd642f'u64
  p1 = 0xe7037ed1a0b428db'u64
  p2 = 0x8ebc6af09c88c6e3'u64
  p3 = 0x589965cc75374cc3'u64
  p4 = 0x1d8e4e27c47d124f'u64

proc wymum(a, b: uint64): uint64 {.inline.} =
  let
    ha: uint64 = a shr 32
    hb: uint64 = b shr 32
    la: uint64 = cast[uint32](a)
    lb: uint64 = cast[uint32](b)
    rh: uint64 = ha * hb
    rm0: uint64 = ha * lb
    rm1: uint64 = hb * la
    rl: uint64 = la * lb
    t: uint64 = rl + (rm0 shl 32)

  var c: uint64 = uint64(t < rl)

  let lo: uint64 = t + (rm1 shl 32)

  c += uint64(lo < t)

  let hi: uint64 = rh + (rm0 shr 32) + (rm1 shr 32) + c

  hi xor lo

proc wyr8(p: pointer): uint64 {.inline.} =
  copyMem(addr(result), p, 8)

proc wyr4(p: pointer): uint64 {.inline.} =
  copyMem(addr(result), p, 4)

proc wyr3(p: ptr UncheckedArray[uint8], k: uint64): uint64 {.inline.} =
  (cast[uint64](p[0]) shl 16) or (cast[uint64](p[k shr 1]) shl 8) or cast[uint64](p[k - 1])

proc wyhash*(key: pointer, len, seed: uint64): uint64 {.inline.} =
  if len == 0'u64:
    return 0

  var p = cast[ptr UncheckedArray[uint8]](key)

  if len < 4:
    return wymum(wymum(wyr3(p, len) xor seed xor p0, seed xor p1), len xor p4)

  elif len <= 8:
    return wymum(wymum(wyr4(p) xor seed xor p0, wyr4(addr p[len - 4]) xor seed xor p1), len xor p4)

  elif len <= 16:
    return wymum(wymum(wyr8(p) xor seed xor p0, wyr8(addr p[len - 8]) xor seed xor p1), len xor p4)

  elif len <= 24:
    return wymum(wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1) xor wymum(wyr8(addr p[len - 8]) xor seed xor p2, seed xor p3), len xor p4)

  elif len <= 32:
    return wymum(wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1) xor wymum(wyr8(addr p[16]) xor seed xor p2, wyr8(addr p[len - 8]) xor seed xor p3), len xor p4)

  var
    seed = seed
    see1 = seed
    i = len

  if i >= 256:
    while i >= 256:
      seed = wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1) xor wymum(wyr8(addr p[16]) xor seed xor p2, wyr8(addr p[24]) xor seed xor p3)

      see1 = wymum(wyr8(addr p[32]) xor see1 xor p1, wyr8(addr p[40]) xor see1 xor p2) xor wymum(wyr8(addr p[48]) xor see1 xor p3, wyr8(addr p[56]) xor see1 xor p0)

      seed = wymum(wyr8(addr p[64]) xor seed xor p0, wyr8(addr p[72]) xor seed xor p1) xor wymum(wyr8(addr p[80]) xor seed xor p2, wyr8(addr p[88]) xor seed xor p3)

      see1 = wymum(wyr8(addr p[96]) xor see1 xor p1, wyr8(addr p[104]) xor see1 xor p2) xor wymum(wyr8(addr p[112]) xor see1 xor p3, wyr8(addr p[120]) xor see1 xor p0)

      seed = wymum(wyr8(addr p[128]) xor seed xor p0, wyr8(addr p[136]) xor seed xor p1) xor wymum(wyr8(addr p[144]) xor seed xor p2, wyr8(addr p[152]) xor seed xor p3)

      see1 = wymum(wyr8(addr p[160]) xor see1 xor p1, wyr8(addr p[168]) xor see1 xor p2) xor wymum(wyr8(addr p[176]) xor see1 xor p3, wyr8(addr p[184]) xor see1 xor p0)

      seed = wymum(wyr8(addr p[192]) xor seed xor p0, wyr8(addr p[200]) xor seed xor p1) xor wymum(wyr8(addr p[208]) xor seed xor p2, wyr8(addr p[216]) xor seed xor p3)

      see1 = wymum(wyr8(addr p[224]) xor see1 xor p1, wyr8(addr p[232]) xor see1 xor p2) xor wymum(wyr8(addr p[240]) xor see1 xor p3, wyr8(addr p[248]) xor see1 xor p0)

      dec(i, 256)

      p = cast[ptr UncheckedArray[uint8]](addr p[256])

  while i >= 32:
    seed = wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1)

    see1 = wymum(wyr8(addr p[16]) xor see1 xor p2, wyr8(addr p[24]) xor see1 xor p3)

    dec(i, 32)

    p = cast[ptr UncheckedArray[uint8]](addr p[32])

  if i == 0:
    discard

  elif i < 4:
    seed = wymum(wyr3(p, i) xor seed xor p0, seed xor p1)

  elif i <= 8:
    seed = wymum(wyr4(p) xor seed xor p0, wyr4(addr p[i - 4]) xor seed xor p1)

  elif i <= 16:
    seed = wymum(wyr8(p) xor seed xor p0, wyr8(addr p[i - 8]) xor seed xor p1)

  elif i <= 24:
    seed = wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1)

    see1 = wymum(wyr8(addr p[i - 8]) xor see1 xor p2, see1 xor p3)

  else:
    seed = wymum(wyr8(p) xor seed xor p0, wyr8(addr p[8]) xor seed xor p1)

    see1 = wymum(wyr8(addr p[16]) xor see1 xor p2, wyr8(addr p[i - 8]) xor see1 xor p3)

  wymum(seed xor see1, len xor p4)

proc wyrand*(state: var uint64): uint64 {.inline.} =
  state += p0

  wymum(state xor p1, state)