}
  }

  /** A sink that writes outgoing data frames of a stream. This class is not thread safe. */
  inner class FramingSink(
    /** True if either side has cleanly shut down this stream. We shall send no more bytes. */
    var finished: Boolean = false,
  ) : Sink {
    /**
     * Buffer of outgoing data. This batches writes of small writes into this sink as larges frames

		runtime.GOMAXPROCS(gomaxprocs)
		// Number of active readers + 10000 * number of active writers.
		var activity int32
		cdone := make(chan bool)
		go writer(resource, numIterations, &activity, cdone)
		var i int
		for i = 0; i < numReaders/2; i++ {
			go reader(resource, numIterations, &activity, cdone)
		}
		go writer(resource, numIterations, &activity, cdone)
		for ; i < numReaders; i++ {

      Multiset<E> multiset, ObjectOutputStream stream) throws IOException {
    int entryCount = multiset.entrySet().size();
    stream.writeInt(entryCount);
    for (Multiset.Entry<E> entry : multiset.entrySet()) {
      stream.writeObject(entry.getElement());
      stream.writeInt(entry.getCount());
    }
  }

  /**
   * Populates a multiset by reading an input stream, as part of deserialization. See {@link

        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")
    void writeBytesWireFormat_throwsIfInsufficientSpace() {
        // Arrange

    }

    // ---------------- Static write tests -----------------
    @Test
    @DisplayName("writeULong writes little endian bytes")
    void testWriteULong() {
        byte[] dest = new byte[4];
        NtlmMessage.writeULong(dest, 0, 0x01020304);
        assertArrayEquals(new byte[] { 4, 3, 2, 1 }, dest, "Writer must be little‑endian");
    }

    @Test

    }

    return result
  }

  override fun toDer(
    writer: DerWriter,
    value: T,
  ) {
    if (typeHint) {
      writer.typeHint = value
    }

    if (isOptional && value == defaultValue) {
      // Nothing to write!
      return
    }

    writer.write(name, tagClass, tag) {
      codec.encode(writer, value)
    }
  }

  /**

pkg math/rand/v2, type Source interface { Uint64 } #61716
pkg math/rand/v2, type Source interface, Uint64() uint64 #61716
pkg math/rand/v2, type Zipf struct #61716
pkg net, method (*TCPConn) WriteTo(io.Writer) (int64, error) #58808
pkg net/http, func FileServerFS(fs.FS) Handler #51971
pkg net/http, func NewFileTransportFS(fs.FS) RoundTripper #51971
pkg net/http, func ServeFileFS(ResponseWriter, *Request, fs.FS, string) #51971

		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])
			if err != nil {
				return 0, err
			}
			totalWritten += int64(n)
			break
		}

		// Copy the block.
		n, err := dst.Write(block)
		if err != nil {
			return 0, err
		}

		// Decrement output size.

            }
        }

        /**
         * Writes a raw line of text to the temporary file.
         *
         * @param line the line of text to write
         */
        public void write(final String line) {
            try {
                writer.write(line);
                writer.write(Constants.LINE_SEPARATOR);

		defer xioutil.ODirectPoolLarge.Put(bufp)
	}

	var written int64
	if odirectEnabled {
		written, err = xioutil.CopyAligned(diskHealthWriter(ctx, w), r, *bufp, fileSize, w)
	} else {
		written, err = io.CopyBuffer(diskHealthWriter(ctx, w), r, *bufp)
	}
	if err != nil {
		w.Close()
		return err
	}

	if written < fileSize && fileSize >= 0 {
		if truncate {