time.Sleep(time.Duration(readRng.Intn(maxSleep)))
			}
		}
	}()

	// Writer
	{
		buf := make([]byte, 1024)
		writeRng := rand.New(rand.NewSource(2))
		for i := 0; i < 2500; i++ {
			writeRng.Read(buf)
			// Write
			n, err := rb.Write(buf[:writeRng.Intn(len(buf))])
			if err != nil {
				t.Fatalf("write failed: %v", err)
			}
			wroteBytes += n
			wrote.Write(buf[:n])

//
// [the Go memory model]: https://go.dev/ref/mem
type RWMutex struct {
	w           Mutex        // held if there are pending writers
	writerSem   uint32       // semaphore for writers to wait for completing readers
	readerSem   uint32       // semaphore for readers to wait for completing writers
	readerCount atomic.Int32 // number of pending readers
	readerWait  atomic.Int32 // number of departing readers
}

            outstr.writeInt(sharedPackages.size());
            for (String str : sharedPackages) {
                outstr.writeUTF(str);
            }

            // Serialize the worker implementation classpath, this is consumed by GradleWorkerMain
            if (runAsModule || implementationModulePath == null) {
                outstr.writeInt(implementationClassPath.size());

        }

        @Override
        public void write(Encoder encoder, DaemonStopEvent value) throws Exception {
            encoder.writeLong(value.timestamp.getTime());
            encoder.writeLong(value.pid);
            encoder.writeBoolean(value.status != null);
            if (value.status != null) {
                encoder.writeByte((byte) value.status.ordinal());
            }

	rLock      mutex    // protects readers, readerPass, writer
	readers    muintptr // list of pending readers
	readerPass uint32   // number of pending readers to skip readers list

	wLock  mutex    // serializes writers
	writer muintptr // pending writer waiting for completing readers

	readerCount atomic.Int32 // number of pending readers
	readerWait  atomic.Int32 // number of departing readers

            outputStream.writeLong(nextBlock.getPos());
            outputStream.writeInt(largestInNextBlock);
            outputStream.writeInt(entries.size());
            for (FreeListEntry entry : entries) {
                outputStream.writeLong(entry.pos.getPos());
                outputStream.writeInt(entry.size);
            }
        }

public class TextQuestionPromptEventSerializer implements Serializer<TextQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, TextQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
        encoder.writeString(value.getDefaultValue());
    }

    @Override

public class YesNoQuestionPromptEventSerializer implements Serializer<YesNoQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, YesNoQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
    }

    @Override
    public YesNoQuestionPromptEvent read(Decoder decoder) throws Exception {

    override suspend fun WriteContext.encode(value: Duration) {
        // Do not use the ISO-8601 format for serialization
        // to work around https://bugs.openjdk.java.net/browse/JDK-8054978
        // on Java 8
        writeLong(value.seconds)
        writeSmallInt(value.nano)
    }

    override suspend fun ReadContext.decode(): Duration =
        Duration.ofSeconds(readLong(), readSmallInt().toLong())

public class BooleanQuestionPromptEventSerializer implements Serializer<BooleanQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, BooleanQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
        encoder.writeBoolean(value.getDefaultValue());
    }

    @Override