this.passwordLength = 1;
        }

        dst[dstIndex] = this.disconnectTid ? (byte) 0x01 : (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        SMBUtil.writeInt2(this.passwordLength, dst, dstIndex);
        return 4;
    }

    @SuppressWarnings("deprecation")
    private static boolean isExternalAuth(final NtlmPasswordAuthenticator pwAuth) {

        return stopwordsService.getStopwordsFile(form.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                }))
                .orElseGet(() -> {
                    throwValidationError(messages -> messages.addErrorsFailedToDownloadStopwordsFile(GLOBAL),

        assertEquals(26, written);

        // Check that padding bytes are zeros
        // The implementation writes 8 bytes with writeInt8 but only increments by 6
        // This means bytes 20-27 will be zero (8 bytes written by writeInt8)
        for (int i = 20; i < 28; i++) {
            assertEquals(0, buffer[i], "Padding byte at position " + i + " should be 0");
        }

     *
     * @param out the output stream to write to
     * @throws IOException if an I/O error occurs during writing
     */
    public void writeOut(final WrittenStreamOut out) throws IOException {
        try (final CurlResponse curlResponse = dictionaryManager.getContentResponse(this);

        return stemmerOverrideService.getStemmerOverrideFile(body.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                }))
                .orElseGet(() -> {
                    throwValidationErrorApi(messages -> messages.addErrorsFailedToDownloadProtwordsFile(GLOBAL));
                    return null;

        return stopwordsService.getStopwordsFile(body.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                }))
                .orElseGet(() -> {
                    throwValidationErrorApi(messages -> messages.addErrorsFailedToDownloadStopwordsFile(GLOBAL));
                    return null;

        return charMappingService.getCharMappingFile(body.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                }))
                .orElseGet(() -> {
                    throwValidationErrorApi(messages -> messages.addErrorsFailedToDownloadProtwordsFile(GLOBAL));
                    return null;

            }

            // set signed flag
            final int oldFlags = SMBUtil.readInt4(data, offset + 16);
            final int flags = oldFlags | ServerMessageBlock2.SMB2_FLAGS_SIGNED;
            SMBUtil.writeInt4(flags, data, offset + 16);

            // Create new Mac instance for thread safety without blocking other operations
            Mac mac;
            try {
                mac = createMacInstance();

        andx.batchLevel = batchLevel + 1;

        dst[start + ANDX_COMMAND_OFFSET] = andxCommand;
        dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
        andxOffset = dstIndex - headerStart;
        writeInt2(andxOffset, dst, start + ANDX_OFFSET_OFFSET);

        andx.useUnicode = useUnicode;
        if (andx instanceof AndXServerMessageBlock) {

            /*

						slowCh <- obj
						continue
					}

					batch = append(batch, obj.Item)

					if len(batch) < *r.Source.Snowball.Batch {
						continue
					}
					writeFn(batch)
					batch = batch[:0]
				}
				writeFn(batch)
				xioutil.SafeClose(slowCh)
			}()
		} else {
			slowCh = walkCh
		}