Class<?> targetClass = desc.forClass();
        writeClass(targetClass);
    }

    @Override
    protected void annotateProxyClass(Class<?> cl) throws IOException {
        writeInt(cl.getInterfaces().length);
        for (Class<?> type : cl.getInterfaces()) {
            writeClass(type);
        }
    }

    private void writeClass(Class<?> targetClass) throws IOException {

    }

    InputStream encoded(String text) {
        def stream = new ByteArrayOutputStream()
        def encoder = new KryoBackedEncoder(stream)
        encoder.writeString(text)
        encoder.writeInt(12)
        encoder.flush()
        return new ByteArrayInputStream(stream.toByteArray())
    }

  }

  @Test
  fun writeSingleByteInt() {
    hpackWriter!!.writeInt(10, 31, 0)
    assertBytes(10)
    hpackWriter!!.writeInt(10, 31, 0xe0)
    assertBytes(0xe0 or 10)
  }

  @Test
  fun writeMultibyteInt() {
    hpackWriter!!.writeInt(1337, 31, 0)
    assertBytes(31, 154, 10)
    hpackWriter!!.writeInt(1337, 31, 0xe0)
    assertBytes(0xe0 or 31, 154, 10)
  }

  @Test

            values.add(entrySerializer.read(decoder));
        }
        return values;
    }

    @Override
    public void write(Encoder encoder, C value) throws Exception {
        encoder.writeInt(value.size());
        for (T t : value) {
            entrySerializer.write(encoder, t);
        }
    }

            valueMap.put(key, value);
        }
        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());
        }
    }

	err = en.Append(0x83, 0xa5, 0x54, 0x6f, 0x74, 0x61, 0x6c)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Total)
	if err != nil {
		err = msgp.WrapError(err, "Total")
		return
	}
	// write "Writes"
	err = en.Append(0xa6, 0x57, 0x72, 0x69, 0x74, 0x65, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Writes)
	if err != nil {
		err = msgp.WrapError(err, "Writes")
		return
	}
	// write "Reads"

  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.

  fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(
          Buffer().writeInt(it.toInt()).readByteArray(),
        )
      }
  }

  /** Allocates and returns `count` fake IPv6 addresses like [::ff00:64, ::ff00:65].  */
  fun allocateIpv6(count: Int): List<InetAddress> {

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = Type(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Type) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt(int(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Type) MarshalMsg(b []byte) (o []byte, err error) {

        throw new UnsupportedOperationException();
    }

    @Override
    public void writeSmallInt(int value) throws IOException {
        writeInt(value);
    }

    @Override
    public void writeSmallLong(long value) throws IOException {
        writeLong(value);
    }

    @Override