return shareAccessHint;
    }

    @Override
    protected int writeBytesWireFormat(byte[] dst, int dstIndex) {
        // Lease break notifications are sent by the server, not written by client
        return 0;
    }

    @Override
    protected int readBytesWireFormat(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        int start = bufferIndex;

    * So, by using FastAPI you are saving development time, bugs, lines of code, and you would probably get the same performance (or better) you would if you didn't use it (as you would have to implement it all in your code)....

import org.jspecify.annotations.NullUnmarked;

/**
 * A generator of {@code TestSuite} instances for testing {@code CharSink} implementations.
 * Generates tests of all methods on a {@code CharSink} given various inputs written to it.
 *
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
@NullUnmarked

   * list. New entries are added at the tail of the list at write time and stale entries are
   * expired from the head of the list.
   */

  /** Returns the time that this entry was last written, in ns. */
  @SuppressWarnings("GoodTime")
  long getWriteTime();

  /** Sets the entry write time in ns. */
  @SuppressWarnings("GoodTime") // b/122668874
  void setWriteTime(long time);

  /**
   * Copies bytes from this hash code into {@code dest}.
   *
   * @param dest the byte array into which the hash code will be written
   * @param offset the start offset in the data
   * @param maxLength the maximum number of bytes to write
   * @return the number of bytes written to {@code dest}
   * @throws IndexOutOfBoundsException if there is not enough room in {@code dest}
   */
  @CanIgnoreReturnValue

        try {
            final NdrBuffer buf = encodeMessage(msg, out);
            final int off = sendFragments(msg, out, buf);

            // last fragment gets written (possibly) using transact/call semantics
            final int have = doSendReceiveFragment(out, off, msg.length, inB);

            if (have != 0) {
                final NdrBuffer hdrBuf = new NdrBuffer(inB, 0);

it should be imported before running 'go mod vendor'.

Go release cycle considerations
===============================

Applying changes to packages that are vendored follows the considerations
written down at go.dev/s/release.

When the Go tree is open for development, a specific change may be pulled in
at any time that it is needed. During the release freeze, the bar for changes

         * Writes a synonym item to the temporary file.
         * If the item is being updated, it writes the new version.
         *
         * @param oldItem The original item from the dictionary.
         * @return The written item, or null if the item was deleted.
         * @throws DictionaryException if the file was updated concurrently.
         */
        public SynonymItem write(final SynonymItem oldItem) {
            try {

    /**
     * Notify when alternate data stream size changes
     */
    public static final int FILE_NOTIFY_CHANGE_STREAM_SIZE = 0x400;
    /**
     * Notify when alternate data stream is written
     */
    public static final int FILE_NOTIFY_CHANGE_STREAM_WRITE = 0x800;

    private final byte[] fileId;
    private final int outputBufferLength;
    private int notifyFlags;
    private int completionFilter;

   * support concurrent multimaps whose content may change while the method is running. The {@link
   * Multimap#asMap} view determines the ordering in which data is written to the stream.
   *
   * <p>The serialized output consists of the number of distinct keys, and then for each distinct
   * key: the key, the number of values for that key, and the key's values.
   */