// string "V1Obj"
			o = append(o, 0xa5, 0x56, 0x31, 0x4f, 0x62, 0x6a)
			if z.ObjectV1 == nil {
				o = msgp.AppendNil(o)
			} else {
				o, err = z.ObjectV1.MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "ObjectV1")
					return
				}
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not omitted
			// string "V2Obj"
			o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)

	if err != nil {
		return
	}
	err = en.WriteInt64(z.BlockSize)
	if err != nil {
		err = msgp.WrapError(err, "BlockSize")
		return
	}
	// write "Index"
	err = en.Append(0xa5, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Index)
	if err != nil {
		err = msgp.WrapError(err, "Index")
		return
	}
	// write "Distribution"

		err = en.WriteString(z.QueuedBuckets[za0001])
		if err != nil {
			err = msgp.WrapError(err, "QueuedBuckets", za0001)
			return
		}
	}
	// write "dbkts"
	err = en.Append(0xa5, 0x64, 0x62, 0x6b, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.DecommissionedBuckets)))
	if err != nil {
		err = msgp.WrapError(err, "DecommissionedBuckets")
		return
	}

	if err != nil {
		return
	}
	err = en.WriteTime(z.Time)
	if err != nil {
		err = msgp.WrapError(err, "Time")
		return
	}
	// write "Token"
	err = en.Append(0xa5, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteString(z.Token)
	if err != nil {
		err = msgp.WrapError(err, "Token")
		return
	}
	return
}

	formatBZ2
)

var magicHeaders = []struct {
	header []byte
	f      format
}{
	{
		header: []byte{0x1f, 0x8b, 8},
		f:      formatGzip,
	},
	{
		// Zstd default header.
		header: []byte{0x28, 0xb5, 0x2f, 0xfd},
		f:      formatZstd,
	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4
		header: []byte{0x4, 0x22, 0x4d, 0x18},

      component: Component,
    ) {
    }
  }

  companion object {
    /** Arbitrary code point that's 2 bytes in UTF-8 and valid in IdnaMappingTable.txt. */
    private const val UNICODE_2 = 0x1a5

    /** Arbitrary code point that's 3 bytes in UTF-8 and valid in IdnaMappingTable.txt. */
    private const val UNICODE_3 = 0x2202

	if err != nil {
		return
	}
	err = en.WriteString(z.Marker)
	if err != nil {
		err = msgp.WrapError(err, "Marker")
		return
	}
	// write "Limit"
	err = en.Append(0xa5, 0x4c, 0x69, 0x6d, 0x69, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Limit)
	if err != nil {
		err = msgp.WrapError(err, "Limit")
		return
	}
	// write "AskDisks"

  }

  private static final String[] BAD_TRY_PARSE_INPUTS = {
    "",
    "+-",
    "+-0",
    " 5",
    "32 ",
    " 55 ",
    "infinity",
    "POSITIVE_INFINITY",
    "0x9A",
    "0x9A.bE-5",
    ".",
    ".e5",
    "NaNd",
    "InfinityF"
  };

  @GwtIncompatible // Doubles.tryParse
  public void testTryParseFailures() {
    for (String badInput : BAD_TRY_PARSE_INPUTS) {

	// string "VersionsSort"
	o = append(o, 0xac, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x6f, 0x72, 0x74)
	o = msgp.AppendUint8(o, uint8(z.VersionsSort))
	// string "Limit"
	o = append(o, 0xa5, 0x4c, 0x69, 0x6d, 0x69, 0x74)
	o = msgp.AppendInt(o, z.Limit)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *WalkOptions) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte

        // Random but realistic GUID
        byte[] testGuid = { (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67, (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF,
                (byte) 0xFE, (byte) 0xDC, (byte) 0xBA, (byte) 0x98, (byte) 0x76, (byte) 0x54, (byte) 0x32, (byte) 0x10 };

        // Security mode with signing required
        int testSecurityMode = 0x0003; // SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED