if publicKey == nil {
			w.Write([]byte{1})
			w.Write(key[:])
		}

		stream, err := sio.AES_256_GCM.Stream(key[:])
		if err != nil {
			bugLogIf(ctx, err)
			return
		}
		// Zero nonce, we only use each key once, and 32 bytes is plenty.
		nonce := make([]byte, stream.NonceSize())
		encw := stream.EncryptWriter(w, nonce, nil)
		defer encw.Close()

	}, nil
}

// To collect RX stats during "mc support perf net"
// RXSample holds the RX bytes for the duration between
// the last peer to connect and the first peer to disconnect.
// This is to improve the RX throughput accuracy.
type netPerfRX struct {
	RX                uint64    // RX bytes
	lastToConnect     time.Time // time at which last peer to connect to us

      throws IOException {
    byte[] bytes = decoded.getBytes(UTF_8);
    try (InputStream decodingStream = encoding.decodingStream(new StringReader(encoded))) {
      for (int i = 0; i < bytes.length; i++) {
        assertThat(decodingStream.read()).isEqualTo(bytes[i] & 0xFF);
      }
      assertThat(decodingStream.read()).isEqualTo(-1);
    }
  }

// MarshalMsg implements msgp.Marshaler
func (z ReplicateDecision) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 0
	_ = z
	o = append(o, 0x80)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ReplicateDecision) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32

    private long v2 = 0x6c7967656e657261L;
    private long v3 = 0x7465646279746573L;

    // The number of bytes in the input.
    private long b = 0;

    // The final 64-bit chunk includes the last 0 through 7 bytes of m followed by null bytes
    // and ending with a byte encoding the positive integer b mod 256.
    private long finalM = 0;

    SipHasher(int c, int d, long k0, long k1) {

        gen.init(param);

        byte[] derived = new byte[16];
        gen.generateBytes(derived, 0, 16);
        return derived;
    }


    /**
     * @param string
     * @return null terminated ASCII bytes
     */
    private static byte[] toCBytes ( String string ) {
        byte[] data = new byte[string.length() + 1];

* `write(data)`: Escreve `data` (`str` ou `bytes`) no arquivo.
* `read(size)`: Lê `size` (`int`) bytes/caracteres do arquivo.
* `seek(offset)`: Vai para o byte na posição `offset` (`int`) no arquivo.
    * Por exemplo, `await myfile.seek(0)` irá para o início do arquivo.

		case err == nil && n != int64(test.length):
			t.Errorf("Test %d: %d bytes were expected, but %d were written", i, test.length, n)
		case err == nil && !bytes.Equal(data[test.offset:test.offset+test.length], buffer):
			t.Errorf("Test %d: Expected bytes: %v, but got: %v", i, data[test.offset:test.offset+test.length], buffer)
		case err != nil && err != test.expError:

    assertThrows(
        IllegalArgumentException.class, () -> Ints.fromByteArray(new byte[Ints.BYTES - 1]));
  }

  public void testFromBytes() {
    assertThat(Ints.fromBytes((byte) 0x12, (byte) 0x13, (byte) 0x14, (byte) 0x15))
        .isEqualTo(0x12131415);
    assertThat(Ints.fromBytes((byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC))
        .isEqualTo(0xFFEEDDCC);
  }

  public void testByteArrayRoundTrips() {

                final byte[] bytes = new byte[4096];
                int length = bis.read(bytes);
                while (length != -1) {
                    if (length != 0) {
                        final int len = length;
                        logger.fine(() -> {
                            try {
                                return "<<< " + new String(bytes, 0, len, encoding);