msg, err := target.toProducerMessage(event)
		if err != nil {
			return err
		}
		msgs = append(msgs, msg)
	}
	return target.producer.SendMessages(msgs)
}

// SendFromStore - reads an event from store and sends it to Kafka.
func (target *KafkaTarget) SendFromStore(key store.Key) (err error) {
	if err = target.init(); err != nil {
		return err
	}
	switch {
	case key.ItemCount == 1:

        return Smb2Constants.SMB2_HEADER_LENGTH;
    }

    /**
     * Reads the SMB2 header from the wire format.
     *
     * @param buffer the buffer to read from
     * @param bufferIndex the starting position in the buffer
     * @return number of bytes read
     */
    protected int readHeaderWireFormat(final byte[] buffer, int bufferIndex) {

	}
	writer.Write([]byte("hello world"))
	// Close before creating the new request.
	w.Close()

	// Set the body equal to the created policy.
	reader := bytes.NewReader(buf.Bytes())

	req, err := http.NewRequest(http.MethodPost, makeTestTargetURL(endPoint, bucketName, "", nil), reader)
	if err != nil {
		return nil, err
	}

	// Set form content-type.
	req.Header.Set("Content-Type", w.FormDataContentType())

pkg bufio, func NewWriter(io.Writer) *Writer
pkg bufio, func NewWriterSize(io.Writer, int) *Writer
pkg bufio, method (*Reader) Buffered() int
pkg bufio, method (*Reader) Peek(int) ([]uint8, error)
pkg bufio, method (*Reader) Read([]uint8) (int, error)
pkg bufio, method (*Reader) ReadByte() (uint8, error)
pkg bufio, method (*Reader) ReadBytes(uint8) ([]uint8, error)

				// Read metadata CRC (added in v2, ignore if not found)
				b = nbuf
			}

			_, e = msgp.CopyToJSON(buf, bytes.NewReader(v))
			if e != nil {
				return nil, e
			}
			data = b
		case 3:
			v, b, e := msgp.ReadBytesZC(b)
			if e != nil {
				return nil, e
			}
			if _, nbuf, e := msgp.ReadUint32Bytes(b); e == nil {
				// Read metadata CRC (added in v2, ignore if not found)

// ReadFrom implements support for calling internal io.ReaderFrom implementations
// returns an error if the underlying ResponseWriter does not implement io.ReaderFrom
func (lrw *ResponseRecorder) ReadFrom(r io.Reader) (int64, error) {
	if lrw.ReaderFrom != nil {
		n, err := lrw.ReaderFrom.ReadFrom(r)
		lrw.bytesWritten += int(n)
		return n, err
	}
	return 0, ErrNotImplemented
}

            // Arrange
            String uuidWithExtra = VALID_UUID_STRING + "EXTRA";

            // Act
            UUID uuid = new UUID(uuidWithExtra);

            // Assert - The implementation only reads what it needs
            assertEquals(TIME_LOW, uuid.time_low);
            assertEquals(TIME_MID, uuid.time_mid);
            assertEquals(TIME_HI_AND_VERSION, uuid.time_hi_and_version);

    }

    /** Returns the file the process writes its pid to. Defaults to "pid" inside baseDir. */
    @Internal
    protected File getPidFile() {
        return new File(baseDir, 'pid')
    }

    /** Reads the pid file and returns the process' pid */
    @Internal
    int getPid() {
        return Integer.parseInt(pidFile.getText('UTF-8').trim())
    }

However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading
* Redundant null checks may increase binary size, hurt performance, and increase cognitive load for readers
* Missing null checks may cause NullPointerException
* Bridging with Kotlin code is polluted with platform types
* Some public APIs have incorrect nullability annotations (both overly restrictive and overly permissive)

	// while background processes are reading the stats for persistence.
	const numWriters = 100 // Simulate many HTTP request handlers.
	const numReaders = 50  // Simulate background stats readers.
	const opsPerGoroutine = 100

	var wg sync.WaitGroup
	for i := range numWriters {
		wg.Add(1)
		go func(writerID int) {
			defer wg.Done()
			for j := 0; j < opsPerGoroutine; j++ {
				switch j % 4 {
				case 0: