switch msgp.UnsafeString(field) {
		case "Total":
			z.Total, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "Size":
			z.Size, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "N":
			z.N, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "N")

	s = 1 + 10 + msgp.DurationSize + 10 + msgp.DurationSize + 13 + msgp.TimeSize + 14 + msgp.TimeSize + 5 + msgp.ArrayHeaderSize
	for za0001 := range z.Tags {
		s += z.Tags[za0001].Msgsize()
	}
	s += 9 + msgp.ArrayHeaderSize
	for za0002 := range z.Metadata {
		s += z.Metadata[za0002].Msgsize()
	}
	s += 9 + msgp.StringPrefixSize + len(z.KMSKeyID)
	return
}

// DecodeMsg implements msgp.Decodable

	v := healingTracker{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodehealingTracker Msgsize() is inaccurate")
	}

	vn := healingTracker{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "id":
			z.DiskID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DiskID")
				return
			}
		case "m":
			z.ScanMode, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ScanMode")
				return
			}
		case "c":
			if msgp.IsNil(bts) {

func (z *PartialOperation) Msgsize() (s int) {
	s = 1 + 7 + msgp.StringPrefixSize + len(z.Bucket) + 7 + msgp.StringPrefixSize + len(z.Object) + 10 + msgp.StringPrefixSize + len(z.VersionID) + 9 + msgp.BytesPrefixSize + len(z.Versions) + 9 + msgp.IntSize + 10 + msgp.IntSize + 7 + msgp.TimeSize + 11 + msgp.BoolSize
	return

		return
	}
	z.ModTime, bts, e = msgp.ReadInt64Bytes(bts)
	if e != nil {
		e = msgp.WrapError(e, "ModTime")
		return
	}
	bts, e = msgp.ReadExactBytes(bts, (z.Signature)[:])
	if e != nil {
		e = msgp.WrapError(e, "Signature")
		return
	}
	{
		var zb0002 uint8
		zb0002, bts, e = msgp.ReadUint8Bytes(bts)
		if e != nil {
			e = msgp.WrapError(e, "Type")
			return
		}

package cmd

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/minio/madmin-go/v3"
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *TierConfigMgr) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--

	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeRStat(b *testing.B) {
	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)

	v := connectReq{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeconnectReq Msgsize() is inaccurate")
	}

	vn := connectReq{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

		s += msgp.NilSize
	} else {
		s += msgp.BoolSize
	}
	s += 6
	if z.Batch == nil {
		s += msgp.NilSize
	} else {
		s += msgp.IntSize
	}
	s += 9
	if z.InMemory == nil {
		s += msgp.NilSize
	} else {
		s += msgp.BoolSize
	}
	s += 9
	if z.Compress == nil {
		s += msgp.NilSize
	} else {
		s += msgp.BoolSize
	}
	s += 12