// overwriting whatever was there before.
func (d *dedup) seenLossy(h uint64) bool {
	cache := &d.recent[uint(h)%uint(len(d.recent))]
	for i := 0; i < len(cache); i++ {
		if atomic.LoadUint64(&cache[i]) == h {
			return true
		}
	}

	// Compute index in set to evict as hash of current set.
	ch := offset64
	for _, x := range cache {
		ch = fnvUint64(ch, x)
	}

				return
			}
		case "p":
			z.Peak, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Peak")
				return
			}
		case "n":
			z.N, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "N")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}

	if err != nil {
		err = msgp.WrapError(err, "XLV1")
		return
	}
	z.ModTime, err = dc.ReadTime()
	if err != nil {
		err = msgp.WrapError(err, "ModTime")
		return
	}
	z.Size, err = dc.ReadInt64()
	if err != nil {
		err = msgp.WrapError(err, "Size")
		return
	}
	z.Mode, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "Mode")
		return
	}

pkg sync/atomic, func CompareAndSwapUintptr(*uintptr, uintptr, uintptr) bool
pkg sync/atomic, func LoadInt32(*int32) int32
pkg sync/atomic, func LoadInt64(*int64) int64
pkg sync/atomic, func LoadPointer(*unsafe.Pointer) unsafe.Pointer
pkg sync/atomic, func LoadUint32(*uint32) uint32
pkg sync/atomic, func LoadUint64(*uint64) uint64
pkg sync/atomic, func LoadUintptr(*uintptr) uintptr
pkg sync/atomic, func StoreInt32(*int32, int32)