}
		case "m":
			z.ScanMode, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ScanMode")
				return
			}
		case "c":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Cache = nil
			} else {
				if z.Cache == nil {
					z.Cache = new(dataUsageCache)
				}
				bts, err = z.Cache.UnmarshalMsg(bts)

				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Compress = nil
			} else {
				if z.Compress == nil {
					z.Compress = new(bool)
				}
				*z.Compress, bts, err = msgp.ReadBoolBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
			}
		case "SmallerThan":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)

// remainder of bytes.
func (b *Bytes) UnmarshalMsg(bytes []byte) ([]byte, error) {
	if b == nil {
		return bytes, errors.New("Bytes: UnmarshalMsg on nil pointer")
	}
	if bytes, err := msgp.ReadNilBytes(bytes); err == nil {
		if *b != nil {
			PutByteBuffer(*b)
		}
		*b = nil
		return bytes, nil
	}
	val, bytes, err := msgp.ReadBytesZC(bytes)
	if err != nil {
		return bytes, err
	}

			z.Started, bts, err = msgp.ReadTimeBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Started")
				return
			}
		case "Replicate":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Replicate = nil
			} else {
				if z.Replicate == nil {
					z.Replicate = new(BatchJobReplicateV1)
				}

		case "Source":
			z.Source, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Source")
				return
			}
		case "Quorum":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Quorum = nil
			} else {
				if z.Quorum == nil {
					z.Quorum = new(int)
				}
				*z.Quorum, bts, err = msgp.ReadIntBytes(bts)

			if err != nil {
				err = msgp.WrapError(err, "CurrentBandwidthInBytesPerSecond")
				return
			}
		case "lt":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.XferRateLrg = nil
			} else {
				if z.XferRateLrg == nil {
					z.XferRateLrg = new(XferStats)
				}
				bts, err = z.XferRateLrg.UnmarshalMsg(bts)

				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "M")
					return
				}
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					za0002 = nil
				} else {
					if za0002 == nil {
						za0002 = new(SRStatus)
					}
					bts, err = za0002.UnmarshalMsg(bts)

				z.PoolStats = (z.PoolStats)[:zb0002]
			} else {
				z.PoolStats = make([]*rebalanceStats, zb0002)
			}
			for za0001 := range z.PoolStats {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.PoolStats[za0001] = nil
				} else {
					if z.PoolStats[za0001] == nil {
						z.PoolStats[za0001] = new(rebalanceStats)
					}

		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "V2Obj":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ObjectV2 = nil
			} else {
				if z.ObjectV2 == nil {
					z.ObjectV2 = new(struct {
						DataDir [16]byte `msg:"DDir"`
					})
				}

			bts, err = z.OlderThan.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "OlderThan")
				return
			}
		case "CreatedBefore":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.CreatedBefore = nil
			} else {
				if z.CreatedBefore == nil {
					z.CreatedBefore = new(time.Time)
				}