err = msgp.WrapError(err)
			return
		}
		var zb0005 uint32
		zb0005, err = dc.ReadArrayHeader()
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		if cap(zb0002) >= int(zb0005) {
			zb0002 = (zb0002)[:zb0005]
		} else {
			zb0002 = make([]lockRequesterInfo, zb0005)
		}
		for zb0003 := range zb0002 {
			err = zb0002[zb0003].DecodeMsg(dc)
			if err != nil {

			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 dataUsageEntryV4
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Cache")
					return
				}
				bts, err = za0002.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Cache", za0001)
					return
				}
				z.Cache[za0001] = za0002
			}
		default:

			zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Histogram")
				return
			}
			if z.Histogram == nil {
				z.Histogram = make(map[string]uint64, zb0004)
			} else if len(z.Histogram) > 0 {
				for key := range z.Histogram {
					delete(z.Histogram, key)
				}
			}
			for zb0004 > 0 {
				var za0005 string
				var za0006 uint64
				zb0004--

				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 TargetReplicationResyncStatus
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "TargetsMap")
					return
				}
				err = za0002.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "TargetsMap", za0001)
					return
				}
				z.TargetsMap[za0001] = za0002
			}
		case "id":

			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 string
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Checksums")
					return
				}
				za0002, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Checksums", za0001)
					return
				}
				z.Checksums[za0001] = za0002
			}

			var zb0009 uint32
			zb0009, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PartIndices")
				return
			}
			if cap(z.PartIndices) >= int(zb0009) {
				z.PartIndices = (z.PartIndices)[:zb0009]
			} else {
				z.PartIndices = make([][]byte, zb0009)
			}
			for za0008 := range z.PartIndices {
				z.PartIndices[za0008], err = dc.ReadBytes(z.PartIndices[za0008])
				if err != nil {

func (z *dataUsageHashMap) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0002 == 0 {
		*z = nil
		return
	}
	*z = make(dataUsageHashMap, zb0002)
	for i := uint32(0); i < zb0002; i++ {
		{
			var zb0003 string
			zb0003, err = dc.ReadString()
			if err != nil {

	_ = field
	for zb0002 > 0 {
		zb0002--
		var za0001 string
		var za0002 string
		za0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err, "Metadata")
			return
		}
		za0002, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err, "Metadata", za0001)
			return
		}
		z.Metadata[za0001] = za0002
	}
	var zb0003 uint32

		{
			var zb0004 uint8
			zb0004, bts, err = msgp.ReadUint8Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "EcN")
				return
			}
			z.EcN = zb0004
		}
		{
			var zb0005 uint8
			zb0005, bts, err = msgp.ReadUint8Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "EcM")
				return
			}
			z.EcM = zb0005
		}
	}
	o = bts
	return
}

			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 string
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "UserDefined")
					return
				}
				za0002, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "UserDefined", za0001)
					return
				}
				z.UserDefined[za0001] = za0002
			}