I_STR     = 0x5308
	I_POP     = 0x5303
	I_PUSH    = 0x5302
	I_LINK    = 0x530c
	I_UNLINK  = 0x530d
	I_PLINK   = 0x5316
	I_PUNLINK = 0x5317

	IF_UNITSEL = -0x7ffb8cca
)

type strbuf struct {
	Maxlen int32
	Len    int32
	Buf    *int8
}

type Strioctl struct {
	Cmd    int32
	Timout int32
	Len    int32
	Dp     *int8
}

type Lifreq struct {
	Name   [32]int8

            def stdout = new java.io.Writer() {
                def buffer = new StringBuilder()
                def written = false

                void write(char[] cbuf, int off, int len) {
                    buffer.append(cbuf, off, len)
                    if (!written && buffer.toString().contains('$PROMPT')) {
                        written = true

	freeBuf *stackWorkBuf // keep around one free buffer for allocation hysteresis

	// cbuf contains conservative pointers to stack objects. If
	// all pointers to a stack object are obtained via
	// conservative scanning, then the stack object may be dead
	// and may contain dead pointers, so it must be scanned
	// defensively.
	cbuf *stackWorkBuf

	// list of stack objects
	// Objects are in increasing address order.

	//   all counters, or possibly mmap the file and do the write
	//   implicitly.
	ctrb := make([]byte, 4)
	wrval := func(val uint32) error {
		var buf []byte
		var towr int
		if cfw.cflavor == coverage.CtrRaw {
			binary.LittleEndian.PutUint32(ctrb, val)
			buf = ctrb
			towr = 4
		} else if cfw.cflavor == coverage.CtrULeb128 {
			cfw.tmp = cfw.tmp[:0]

        this.in = new Reader() {
            Reader delegate = null;

            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                if (delegate == null) {
                    delegate = transform(original);
                }
                return delegate.read(cbuf, off, len);
            }

            @Override
            public void close() throws IOException {

		if err := w.Close(); err != nil {
			t.Errorf("error closing writer: %v", err)
		}
	}()

	rbuf := bufio.NewReader(r)
	for i := 0; i < 3; i++ {
		write <- i
		b, err := rbuf.ReadBytes('\n')
		if err != nil {
			t.Fatal(err)
		}
		t.Logf("%s\n", bytes.TrimSpace(b))
	}

	close(write)
	b, err := rbuf.ReadBytes('\n')
	if err != io.EOF || len(b) != 0 {
		t.Errorf(`ReadBytes: %q, %v; want "", io.EOF`, b, err)

    private val charset: Charset,
  ) : Reader() {
    private var closed: Boolean = false
    private var delegate: Reader? = null

    @Throws(IOException::class)
    override fun read(
      cbuf: CharArray,
      off: Int,
      len: Int,
    ): Int {
      if (closed) throw IOException("Stream closed")

      val finalDelegate =
        delegate ?: InputStreamReader(

		}

		rbuf := make([]byte, 2500)
		n, err := io.ReadFull(resp.Body, rbuf)
		checkErr(err, "2500 byte ReadFull")
		if n != 2500 {
			fatalf("ReadFull only read %d bytes", n)
		}
		if test.compressed == false && !bytes.Equal(bytes.Repeat([]byte{'x'}, 2500), rbuf) {
			fatalf("ReadFull didn't read 2500 'x'; got %q", string(rbuf))
		}
		resp.Body.Close()

   * characters that it could read in read(char[], int, int).
   */
  private static Reader newNonBufferFillingReader(Reader reader) {
    return new FilterReader(reader) {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {
        // if a buffer isn't being cleared correctly, this method will eventually start being called
        // with a len of 0 forever
        if (len <= 0) {

   * characters that it could read in read(char[], int, int).
   */
  private static Reader newNonBufferFillingReader(Reader reader) {
    return new FilterReader(reader) {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {
        // if a buffer isn't being cleared correctly, this method will eventually start being called
        // with a len of 0 forever
        if (len <= 0) {