err = msgp.WrapError(err)
				return
			}
			(*z)[zb0003] = struct{}{}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z dataUsageHashMap) Msgsize() (s int) {
	s = msgp.ArrayHeaderSize
	for zb0004 := range z {
		s += msgp.StringPrefixSize + len(zb0004)
	}
	return
}

func calcAvg(x, y float64, n1, n2 int64) float64 {
	if n1+n2 == 0 {
		return 0
	}
	avg := (x*float64(n1) + y*float64(n2)) / float64(n1+n2)
	return avg
}

// Add a new transfer
func (rx *XferStats) addSize(sz int64, t time.Duration) {
	if rx.measure == nil {
		rx.measure = newRateMeasurement(time.Now())
	}
	rx.measure.incrementBytes(uint64(sz))
	rx.Curr = rx.measure.getExpMovingAvgBytesPerSecond()

PSED)) {\n      this.expand()\n    } else {\n      this.collapse()\n    }\n  }\n\n  autoCollapse(resize = false) {\n    if (!this._options.autoCollapseSize) {\n      return\n    }\n\n    const $bodySelector = $(SELECTOR_BODY)\n\n    if ($(window).width() <= this._options.autoCollapseSize) {\n      if (!$bodySelector.hasClass(CLASS_NAME_OPEN)) {\n        this.collapse()\n      }\n    } else if (resize === true) {\n      if ($bodySelector.hasClass(CLASS_NAME_OPEN)) {\n        $bodySelector.removeC...

}

// Bytes returns msgpack encoded config with format and version headers.
func (config *TierConfigMgr) Bytes() ([]byte, error) {
	config.RLock()
	defer config.RUnlock()
	data := make([]byte, 4, config.Msgsize()+4)

	// Initialize the header.
	binary.LittleEndian.PutUint16(data[0:2], tierConfigFormat)
	binary.LittleEndian.PutUint16(data[2:4], tierConfigVersion)

	// Marshal the tier config

// Save config to supplied ObjectLayer api.
func (b *BucketMetadata) Save(ctx context.Context, api ObjectLayer) error {
	if err := b.parseAllConfigs(ctx, api); err != nil {
		return err
	}

	data := make([]byte, 4, b.Msgsize()+4)

	// Initialize the header.
	binary.LittleEndian.PutUint16(data[0:2], bucketMetadataFormat)
	binary.LittleEndian.PutUint16(data[2:4], bucketMetadataVersion)

	// Marshal the bucket metadata

		// Save the current part name and size.
		partSize := fi.Parts[partIndex].Size

		partLength := partSize - partOffset
		// partLength should be adjusted so that we don't write more data than what was requested.
		if partLength > (length - totalBytesRead) {
			partLength = length - totalBytesRead
		}

		tillOffset := erasure.ShardFileOffset(partOffset, partLength, partSize)
		// Get the checksums of the current part.

	lgDir := ctx.String("log-dir")
	if lgDir == "" {
		return os.Stderr, nil
	}
	lgDirAbs, err := filepath.Abs(lgDir)
	if err != nil {
		return nil, err
	}
	lgSize := ctx.Int("log-size")

	var fileNameFunc func() string
	if ctx.IsSet("log-prefix") {
		fileNameFunc = func() string {

	}
	return m.sendLocked(msg)
}

// sendLocked the message. msg.Seq and msg.MuxID will be set.
// m.respMu must be held.
func (m *muxClient) sendLocked(msg message) error {
	dst := GetByteBufferCap(msg.Msgsize())
	msg.Seq = m.SendSeq
	msg.MuxID = m.MuxID
	msg.Flags |= m.BaseFlags
	if debugPrint {
		fmt.Println("Client sending", &msg, "to", m.parent.Remote)
	}
	m.SendSeq++

	dst, err := msg.MarshalMsg(dst)

        int maximumBufferSize = getContext().getConfig().getMaximumBufferSize();
        int msgSize = nextCommand != 0 ? nextCommand : size;
        if ( msgSize > maximumBufferSize ) {
            throw new IOException(String.format("Message size %d exceeds maxiumum buffer size %d", msgSize, maximumBufferSize));
        }

        ServerMessageBlock2Response cur = (ServerMessageBlock2Response) response;

		b.ReplicatedCount++
		if rs.TransferDuration > 0 {
			b.Latency.update(rs.TransferSize, rs.TransferDuration)
			b.updateXferRate(rs.TransferSize, rs.TransferDuration)
		}
	case rs.Failed:
		b.FailStats.addsize(rs.TransferSize, rs.Err)
	case rs.Pending:
	}
}

type replStat struct {
	Arn       string
	Completed bool
	Pending   bool
	Failed    bool
	opType    replication.Type
	// transfer size