// Use a new Writer because we don't support change the dynamic table
    // size after Writer constructed.
    val writer = Hpack.Writer(110, false, bytesOut)
    writer.writeHeaders(headerBlock)
    assertThat(bytesOut).isEqualTo(bytesIn)
    assertThat(writer.headerCount).isEqualTo(2)
    val tableLength = writer.dynamicTable.size
    var entry = writer.dynamicTable[tableLength - 1]!!

    }

    @Override
    public void write(Encoder encoder, MultiChoiceAddress address) throws IOException {
        UUID canonicalAddress = address.getCanonicalAddress();
        encoder.writeLong(canonicalAddress.getMostSignificantBits());
        encoder.writeLong(canonicalAddress.getLeastSignificantBits());
        encoder.writeInt(address.getPort());
        encoder.writeSmallInt(address.getCandidates().size());

            List<DaemonStopEvent> stopEvents = registry.stopEvents;
            encoder.writeInt(stopEvents.size());
            for (DaemonStopEvent stopEvent : stopEvents) {
                DaemonStopEvent.SERIALIZER.write(encoder, stopEvent);
            }
        }

	buf := newsehbuf(ctxt, nodes)
	buf.write8(flags | 1)            // Flags + version
	buf.write8(uint8(movbp.Link.Pc)) // Size of prolog
	buf.write8(nodes)                // Count of nodes
	buf.write8(SEH_REG_BP)           // FP register

	// Notes are written in reverse order of appearance.
	buf.write8(uint8(movbp.Link.Pc))
	buf.writecode(UWOP_SET_FPREG, 0)

	buf.write8(uint8(pushbp.Link.Pc))

    @Override
    public void write(Encoder encoder, VisitableURLClassLoader.Spec spec) throws Exception {
        if (spec instanceof MixInLegacyTypesClassLoader.Spec) {
            encoder.writeByte(MIXIN_CLASSLOADER_SPEC);
        } else {
            encoder.writeByte(VISITABLE_URL_CLASSLOADER_SPEC);
        }

        encoder.writeString(spec.getName());
        encoder.writeInt(spec.getClasspath().size());

        }
        return valueMap;
    }

    @Override
    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }

    @Override

  fun inflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      inflater.reset()
    }

    deflatedBytes.writeAll(buffer)
    deflatedBytes.writeInt(OCTETS_TO_ADD_BEFORE_INFLATION)

    val totalBytesToRead = inflater.bytesRead + deflatedBytes.size

    // We cannot read all, as the source does not close.

	nextID     int64
	inFlight   map[int64]chan<- *ProgResponse
	outputFile map[OutputID]string // object => abs path on disk

	// writeMu serializes writing to the child process.
	// It must never be held at the same time as mu.
	writeMu sync.Mutex
}

// ProgCmd is a command that can be issued to a child process.
//
// If the interface needs to grow, we can add new commands or new versioned

        encodeStrings(encoder, spec.getResourcePrefixes());
    }

    private void encodeStrings(Encoder encoder, Set<String> strings) throws Exception {
        encoder.writeInt(strings.size());
        for (String string : strings) {
            encoder.writeString(string);
        }
    }

    @Override
    public FilteringClassLoader.Spec read(Decoder decoder) throws Exception {

		t.Skip("-buildmode=pie not supported")
	}

	t.Parallel()

	tmpl := template.Must(template.New("pie").Parse(pieSourceTemplate))

	writeGo := func(t *testing.T, dir string) {
		f, err := os.Create(filepath.Join(dir, "pie.go"))
		if err != nil {
			t.Fatal(err)
		}

		// Passing a 100-element slice here will cause