}
}

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

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

	return
}

// DecodeMsg implements msgp.Decodable
func (z *rstats) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(rstats, zb0002)
	}
	for zb0001 := range *z {
		if dc.IsNil() {

					status = rebalCompleted
					traceMsg = fmt.Sprintf("completed at %s", now)
				default:
					status = rebalFailed
					traceMsg = fmt.Sprintf("stopped at %s with err: %v", now, rebalErr)
				}

				z.rebalMu.Lock()
				z.rebalMeta.PoolStats[poolIdx].Info.Status = status
				z.rebalMeta.PoolStats[poolIdx].Info.EndTime = now
				z.rebalMu.Unlock()

			case <-timer.C:
				notify = false

						Value:       float64(s.ProxyStats.RmvTagFailedTotal),
					})
				}
				if stats.hasReplicationUsage() {
					for arn, stat := range stats.Stats {
						metrics = append(metrics, MetricV2{
							Description:    getRepFailedBytesLastMinuteMD(bucketMetricNamespace),
							Value:          float64(stat.Failed.LastMinute.Bytes),
							VariableLabels: map[string]string{"bucket": bucket, "targetArn": arn},

	TgtXferStats  map[string]map[RMetricName]XferStats `json:"tgtTransferStats"`
	QStats        InQueueMetric                        `json:"queueStats"`
	MRFStats      ReplicationMRFStats                  `json:"mrfStats"`
}

// getNodeQueueStats returns replication operational stats at the node level
func (r *ReplicationStats) getNodeQueueStats(bucket string) (qs ReplQNodeStats) {

    assertThat(EMPTY_PAIRED_STATS.toString())
        .isEqualTo("PairedStats{xStats=Stats{count=0}, yStats=Stats{count=0}}");
    assertThat(MANY_VALUES_PAIRED_STATS.toString())
        .isEqualTo(
            "PairedStats{xStats="
                + MANY_VALUES_PAIRED_STATS.xStats()
                + ", yStats="
                + MANY_VALUES_PAIRED_STATS.yStats()
                + ", populationCovariance="

    assertThat(EMPTY_PAIRED_STATS.toString())
        .isEqualTo("PairedStats{xStats=Stats{count=0}, yStats=Stats{count=0}}");
    assertThat(MANY_VALUES_PAIRED_STATS.toString())
        .isEqualTo(
            "PairedStats{xStats="
                + MANY_VALUES_PAIRED_STATS.xStats()
                + ", yStats="
                + MANY_VALUES_PAIRED_STATS.yStats()
                + ", populationCovariance="

   *
   * <ul>
   *   <li>Both {@code xStats} and {@code yStats} must have the same {@code count}.
   *   <li>If that {@code count} is 1, {@code sumOfProductsOfDeltas} must be exactly 0.0.
   *   <li>If that {@code count} is more than 1, {@code sumOfProductsOfDeltas} must be finite.
   * </ul>
   */
  PairedStats(Stats xStats, Stats yStats, double sumOfProductsOfDeltas) {
    this.xStats = xStats;
    this.yStats = yStats;

	"github.com/minio/minio-go/v7"
)

//go:generate msgp -file $GOFILE

// RStat has replication error stats
type RStat struct {
	Count int64 `json:"count"`
	Bytes int64 `json:"bytes"`
}

// RTimedMetrics has replication error stats for various time windows
type RTimedMetrics struct {
	LastHour    ReplicationLastHour `json:"lastHour"`
	SinceUptime RStat               `json:"sinceUptime"`
	LastMinute  ReplicationLastMinute

			return
		}
		switch msgp.UnsafeString(field) {
		case "Stats":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Stats")
				return
			}
			if z.Stats == nil {
				z.Stats = make(map[string]*BucketReplicationStat, zb0002)
			} else if len(z.Stats) > 0 {
				clear(z.Stats)
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string