count++
		}
	}
	if count > 0 {
		lrg := XferStats{
			Avg:  lavg / float64(count),
			Curr: lcurr / float64(count),
			Peak: lpeak,
		}
		sml := XferStats{
			Avg:  savg / float64(count),
			Curr: scurr / float64(count),
			Peak: speak,
		}
		qs.XferStats[Large] = lrg
		qs.XferStats[Small] = sml
		qs.XferStats[Total] = XferStats{
			Avg:  (savg + lavg) / float64(count),

	// Replication latency information
	Latency ReplicationLatency `json:"replicationLatency"`
	// transfer rate for large uploads
	XferRateLrg *XferStats `json:"largeTransferRate" msg:"lt"`
	// transfer rate for small uploads
	XferRateSml *XferStats `json:"smallTransferRate" msg:"st"`
	// Endpoint is the replication target endpoint
	Endpoint string `json:"-"`
	// Secure is true if the replication target endpoint is secure

func (z SMA) Msgsize() (s int) {
	s = 1 + 5 + msgp.Float64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *XferStats) 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 k, v := range v.Failed.ErrCounts {
				v2.Failed.ErrCounts[k] += v
			}
			if v2.XferStats == nil {
				v2.XferStats = make(map[replication.MetricName]replication.XferStats)
			}
			for rm, x := range v.XferStats {
				x2, ok := v2.XferStats[replication.MetricName(rm)]
				if !ok {
					x2 = replication.XferStats{}
				}
				x2.AvgRate += x.Avg
				x2.CurrRate += x.Curr
				if x.Peak > x2.PeakRate {

	}
}

func BenchmarkMarshalMsgXferStats(b *testing.B) {
	v := XferStats{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgXferStats(b *testing.B) {
	v := XferStats{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()

				if err != nil {
					err = msgp.WrapError(err, "XferRateLrg")
					return
				}
				z.XferRateLrg = nil
			} else {
				if z.XferRateLrg == nil {
					z.XferRateLrg = new(XferStats)
				}
				err = z.XferRateLrg.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "XferRateLrg")
					return
				}
			}
		case "st":
			if dc.IsNil() {

				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "XferRateLrg")
					return
				}
				z.XferRateLrg = nil
			} else {
				if z.XferRateLrg == nil {
					z.XferRateLrg = new(XferStats)
				}
				err = z.XferRateLrg.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "XferRateLrg")
					return
				}
			}
		case "st":
			if dc.IsNil() {
				err = dc.ReadNil()