streamId: Int,
    byteCount: Long,
  ) {
    var byteCount = byteCount
    while (byteCount > 0L) {
      val length = minOf(maxFrameSize.toLong(), byteCount)
      byteCount -= length
      frameHeader(
        streamId = streamId,
        length = length.toInt(),
        type = TYPE_CONTINUATION,
        flags = if (byteCount == 0L) FLAG_END_HEADERS else 0,
      )

        result.writeDecimalLong(xy - 80L)
      }
    }
    while (byteCount < limit) {
      result.writeByte(dot)
      result.writeDecimalLong(readVariableLengthLong())
    }
    return result.readUtf8()
  }

  fun readRelativeObjectIdentifier(): String {
    val result = Buffer()
    val dot = '.'.code.toByte().toInt()
    while (byteCount < limit) {
      if (result.size > 0) {
        result.writeByte(dot)

        wordCount /= 2;
        dst[start] = (byte) (wordCount & 0xFF);

        byteCount = writeBytesWireFormat(dst, dstIndex + 2);
        dst[dstIndex] = (byte) (byteCount & 0xFF);
        dstIndex++;
        dst[dstIndex++] = (byte) (byteCount >> 8 & 0xFF);
        dstIndex += byteCount;

        /* Normally, without intervention everything would batch

      }
    }

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }
      if (bytesRemaining == 0L) return -1

      val read = super.read(sink, minOf(bytesRemaining, byteCount))
      if (read == -1L) {

        this.wordCount /= 2;
        dst[start] = (byte) (this.wordCount & 0xFF);

        this.byteCount = writeBytesWireFormat(dst, dstIndex + 2);
        dst[dstIndex] = (byte) (this.byteCount & 0xFF);
        dstIndex++;
        dst[dstIndex++] = (byte) (this.byteCount >> 8 & 0xFF);
        dstIndex += this.byteCount;

        /*
         * Normally, without intervention everything would batch

        assertTrue(result.contains("byteCount=8"));
        assertTrue(result.contains("oemDomainName=TEST_DOMAIN"));
    }

    // Helper method to set protected byteCount field using reflection
    private void setByteCount(SmbComNegotiateResponse response, int byteCount) {
        try {
            Field field = response.getClass().getSuperclass().getDeclaredField("byteCount");
            field.setAccessible(true);

            }
            bufferIndex += wordCount * 2;
        }

        byteCount = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        if (byteCount != 0) {
            int n = readBytesWireFormat(buffer, bufferIndex);
            if ((n != byteCount) && (LogStream.level >= 5)) {
                log.println("byteCount=" + byteCount + " but readBytesWireFormat returned " + n);
            }

        }

        this.byteCount = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        if (this.byteCount != 0) {
            int n = readBytesWireFormat(buffer, bufferIndex);
            if ((n != this.byteCount) && log.isTraceEnabled()) {
                log.trace("byteCount=" + this.byteCount + " but readBytesWireFormat returned " + n);
            }

  fun writeData(
    streamId: Int,
    outFinished: Boolean,
    buffer: Buffer?,
    byteCount: Long,
  ) {
    // Empty data frames are not flow-controlled.
    if (byteCount == 0L) {
      writer.data(outFinished, streamId, buffer, 0)
      return
    }

    var byteCount = byteCount
    while (byteCount > 0L) {
      var toWrite: Int
      withLock {
        try {

        SMBUtil.writeInt2(83, buffer, 36); // andxOffset (33 + 50)
        SMBUtil.writeInt2(20, buffer, 42); // byteCount

        // Setup andx command data at offset 83 (absolute position from buffer start)
        buffer[83] = 2; // andx wordCount
        SMBUtil.writeInt2(10, buffer, 88); // andx byteCount

        int length = testBlock.decode(buffer, 0);

        assertTrue(length > 0);