int start = bufferIndex;

        bufferIndex += 2; // reserved
        dataCompactionMode = readInt2( buffer, bufferIndex );
        bufferIndex += 4; // 2 reserved
        dataLength = readInt2( buffer, bufferIndex );
        bufferIndex += 2;
        dataOffset = readInt2( buffer, bufferIndex );
        bufferIndex += 12; // 10 reserved

        return bufferIndex - start;
    }

    @Override
    protected int readParametersWireFormat ( byte[] buffer, int bufferIndex, int len ) {
        this.available = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        setStatus(SMBUtil.readInt2(buffer, bufferIndex));
        return 6;
    }


    @Override

            int bufferCount = pacStream.readInt();
            int version = pacStream.readInt();

            if ( version != PacConstants.PAC_VERSION ) {
                throw new PACDecodingException("Unrecognized PAC version " + version);
            }

            for ( int bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++ ) {
                int bufferType = pacStream.readInt();

        int start = bufferIndex;
        int nciphers = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        this.ciphers = new int[nciphers];
        for ( int i = 0; i < nciphers; i++ ) {
            this.ciphers[ i ] = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
        }

        return bufferIndex - start;
    }

        int start = bufferIndex;
        int nalgos = SMBUtil.readInt2(buffer, bufferIndex);
        int nsalt = SMBUtil.readInt2(buffer, bufferIndex + 2);
        bufferIndex += 4;

        this.hashAlgos = new int[nalgos];
        for ( int i = 0; i < nalgos; i++ ) {
            this.hashAlgos[ i ] = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
        }

   * 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.
   *

	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Num":
			z.Num, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Num")
				return
			}
		case "String":
			z.String, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "String")
				return
			}

			{
				var zb0002 uint8
				zb0002, err = dc.ReadUint8()
				if err != nil {
					err = msgp.WrapError(err, "status")
					return
				}
				z.status = scanStatus(zb0002)
			}
		case "rec":
			z.recursive, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "recursive")
				return
			}
		case "v":
			z.dataVersion, err = dc.ReadUint8()
			if err != nil {

              // 1NNNNNNN
              val index = readInt(b, PREFIX_7_BITS)
              readIndexedHeader(index - 1)
            }
            b == 0x40 -> {
              // 01000000
              readLiteralHeaderWithIncrementalIndexingNewName()
            }
            b and 0x40 == 0x40 -> {
              // 01NNNNNN
              val index = readInt(b, PREFIX_6_BITS)

		}
		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