Smb2LogoffRequest req = newRequest();
        byte[] buf = new byte[offset + 8]; // extra space for safety

        // Act
        int written = req.writeBytesWireFormat(buf, offset);

        // Assert: should write exactly 4 bytes
        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0

        assertArgumentNotNull("element", element);
        assertArgumentNotNull("buf", buf);

        final String tag = element.getTagName();
        buf.append('<');
        buf.append(tag);
        appendAttrs(element.getAttributes(), buf);
        buf.append('>');
        appendChildren(element.getChildNodes(), buf);
        buf.append("</");
        buf.append(tag);

	var fi FileInfo
	var err error
	var inData xlMetaInlineData
	if buf, data, e := isIndexedMetaV2(xlMetaBuf); e != nil {
		return FileInfo{}, e
	} else if buf != nil {
		inData = data
		fi, err = buf.ToFileInfo(volume, path, versionID, true)
		if len(buf) != 0 && errors.Is(err, errFileNotFound) {
			// This special case is needed to handle len(xlMeta.versions) == 0
			return FileInfo{

	headerVer, metaVer uint
}

func decodeXLHeaders(buf []byte) (x xlHeaders, b []byte, err error) {
	x.headerVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	x.metaVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	if x.headerVer > xlHeaderVersion {
		return x, buf, fmt.Errorf("decodeXLHeaders: Unknown xl header version %d", x.headerVer)
	}

                buf.start = off;
                buf.reset();
                msg.encode_header(buf);
                buf.enc_ndr_long(msg.alloc_hint);
                buf.enc_ndr_short(0); /* context id */
                buf.enc_ndr_short(msg.getOpnum());
            }

            if ((msg.flags & DCERPC_LAST_FRAG) == DCERPC_LAST_FRAG) {

		// Add input readahead.
		// We use 2 buffers, so we always have a full buffer of input.
		pool := globalBytePoolCap.Load()
		bufA := pool.Get()
		bufB := pool.Get()
		defer pool.Put(bufA)
		defer pool.Put(bufB)
		ra, err := readahead.NewReaderBuffer(data, [][]byte{bufA[:fi.Erasure.BlockSize], bufB[:fi.Erasure.BlockSize]})
		if err == nil {
			toEncode = ra
			defer ra.Close()
		}
	}

		}

		return nil, ObjectInfo{}, err
	}
	defer r.Close()

	buf, err := io.ReadAll(r)
	if err != nil {
		return nil, ObjectInfo{}, err
	}
	if len(buf) == 0 {
		return nil, ObjectInfo{}, errConfigNotFound
	}
	return buf, r.ObjInfo, nil
}

func readConfig(ctx context.Context, store objectIO, configFile string) ([]byte, error) {
	buf, _, err := readConfigWithMetadata(ctx, store, configFile, ObjectOptions{})

	// Calculate the size of the bitrot file and compare
	// it with the actual file size.
	if left != bitrotShardFileSize(partSize, shardSize, algo) {
		return errFileCorrupt
	}

	bufp := xioutil.ODirectPoolSmall.Get()
	defer xioutil.ODirectPoolSmall.Put(bufp)

	for left > 0 {
		// Read expected hash...
		h.Reset()
		n, err := io.ReadFull(r, hashBuf)
		if err != nil {

            buf.append("-");
            buf.append(i);
            buf.append(".html\">File ");
            buf.append(count);
            buf.append("-");
            buf.append(i);
            buf.append("</a><br>");
            buf.append("<a href=\"dir");
            buf.append(count);
            buf.append("-");
            buf.append(i);
            buf.append("/index.html\">Dir ");
            buf.append(count);

    void encode_header(final NdrBuffer buf) {
        buf.enc_ndr_small(5); /* RPC version */
        buf.enc_ndr_small(0); /* minor version */
        buf.enc_ndr_small(ptype);
        buf.enc_ndr_small(flags);
        buf.enc_ndr_long(0x00000010); /* Little-endian / ASCII / IEEE */
        buf.enc_ndr_short(length);
        buf.enc_ndr_short(0); /* length of auth_value */
        buf.enc_ndr_long(call_id);
    }