return flags;
    }

    /**
     * Constructs the LanManager response to the given Type-2 message using
     * the supplied password.
     *
     * @param type2 The Type-2 message.
     * @param password The password.
     * @return A <code>byte[]</code> containing the LanManager response.
     */

            andxCommand = (byte) 0xFF;
            andx = null;
        } else if (andx == null) {
            andxCommand = (byte) 0xFF;
            throw new RuntimeException("no andx command supplied with response");
        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

            bufferIndex = headerStart + andxOffset;

   * note that listeners added after this point may be executed before those previously added, and
   * note that the execution order of all listeners is ultimately chosen by the implementations of
   * the supplied executors.
   *
   * <p>This method is idempotent. Calling it several times in parallel is semantically equivalent
   * to calling it exactly once.
   *
   * @since 10.0 (present in 1.0 as {@code run})
   */

    private MimeMap mimeMap;
    /** The CSS style for HTML rendering */
    private String style;
    /** The NTLM SSP handler */
    private NtlmSsp ntlmSsp;
    /** Flag indicating if credentials were supplied */
    private boolean credentialsSupplied;
    /** Flag to enable basic authentication */
    private boolean enableBasic;
    /** Flag to allow insecure basic authentication */
    private boolean insecureBasic;

		globalBytePoolCap.Load().Put(b.byteBuf)
		b.byteBuf = nil
	}
	return err
}

// newStreamingBitrotWriterBuffer returns streaming bitrot writer implementation.
// The output is written to the supplied writer w.
func newStreamingBitrotWriterBuffer(w io.Writer, algo BitrotAlgorithm, shardSize int64) io.Writer {

        assertTrue(n > 0);
        assertNull(block.andx, "andx should be cleared when offset is 0");
    }

    @Test
    @DisplayName("decode throws when andx command present but no andx object supplied")
    void testDecodeWithAndxCommandButNoObject() {
        DummyAndXBlock block = new DummyAndXBlock() {
            @Override
            int readHeaderWireFormat(byte[] buffer, int bufferIndex) {

    /**
     * The media-type multipart/form-data follows the rules of all multipart MIME data streams as
     * outlined in RFC 2046. In forms, there are a series of fields to be supplied by the user who
     * fills out the form. Each field has a name. Within a given form, the names are unique.
     */
    @JvmField
    val FORM = "multipart/form-data".toMediaType()

import jcifs.util.Strings;

/**
 * This class stores and encrypts NTLM user credentials.
 *
 * Contrary to {@link NtlmPasswordAuthentication} this does not cause guest authentication
 * when the "guest" username is supplied. Use {@link AuthenticationType} instead.
 *
 * @author mbechler
 */
public class NtlmPasswordAuthenticator implements Principal, CredentialsInternal, Serializable, AutoCloseable {

    /**
     *
     */

import java.util.TreeMap;
import java.util.TreeSet;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@code Multimap} whose keys and values are ordered by their natural ordering or
 * by supplied comparators. In all cases, this implementation uses {@link Comparable#compareTo} or
 * {@link Comparator#compare} instead of {@link Object#equals} to determine equivalence of
 * instances.
 *

     * For example, resolves "[3.8,4.0)" to "3.8", "3.8.1", "3.8.2".
     * The returned list of versions is only dependent on the configured repositories and their contents.
     * The supplied request may also refer to a single concrete version rather than a version range.
     * In this case though, the result contains simply the (parsed) input version, regardless of the
     * repositories and their contents.
     *