}
		switch msgp.UnsafeString(field) {
		case "Total":
			z.Total, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "Writes":
			z.Writes, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Writes")
				return
			}
		case "Reads":
			z.Reads, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Reads")
				return

				return
			}
		case "ob":
			z.Objects, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Objects")
				return
			}
		case "dm":
			z.DeleteMarkers, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkers")
				return
			}
		case "obf":
			z.ObjectsFailed, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ObjectsFailed")

		case "UpperBound":
			{
				var zb0002 int64
				zb0002, err = dc.ReadInt64()
				if err != nil {
					err = msgp.WrapError(err, "UpperBound")
					return
				}
				z.UpperBound = BatchJobSize(zb0002)
			}
		case "LowerBound":
			{
				var zb0003 int64
				zb0003, err = dc.ReadInt64()
				if err != nil {
					err = msgp.WrapError(err, "LowerBound")
					return
				}

		case "ReplicatedSize":
			z.ReplicatedSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ReplicatedSize")
				return
			}
		case "FailedSize":
			z.FailedSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "FailedSize")
				return
			}
		case "FailedCount":
			z.FailedCount, err = dc.ReadInt64()
			if err != nil {

				return
			}
		case "n":
			z.Number, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Number")
				return
			}
		case "s":
			z.Size, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "as":
			z.ActualSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ActualSize")
				return

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Count":
			z.Count, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "Bytes":
			z.Bytes, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Bytes")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {

			}
		case "EcM":
			z.ErasureM, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ErasureM")
				return
			}
		case "EcN":
			z.ErasureN, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ErasureN")
				return
			}
		case "EcBSize":
			z.ErasureBlockSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ErasureBlockSize")

    }
    val padding = if (flags and FLAG_PADDED != 0) source.readByte() and 0xff else 0
    val promisedStreamId = source.readInt() and 0x7fffffff
    val headerBlockLength = lengthWithoutPadding(length - 4, flags, padding) // - 4 for readInt().
    val headerBlock = readHeaderBlock(headerBlockLength, padding, flags, streamId)
    handler.pushPromise(streamId, promisedStreamId, headerBlock)
  }

				}
			}
		case "PendingSize":
			z.PendingSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "PendingSize")
				return
			}
		case "FailedSize":
			z.FailedSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "FailedSize")
				return
			}
		case "PendingCount":
			z.PendingCount, err = dc.ReadInt64()
			if err != nil {

   * of distinct keys in a multimap serialized by {@link #writeMultimap(Multimap,
   * ObjectOutputStream)}.
   */
  static int readCount(ObjectInputStream stream) throws IOException {
    return stream.readInt();
  }

  /**
   * Stores the contents of a map in an output stream, as part of serialization. It does not support
   * concurrent maps whose content may change while the method is running.
   *