public void testCollisionsDueToIncorrectSignExtension() {
    byte[] col1 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x80};
    byte[] col2 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x81};
    byte[] col3 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0xff};

    ImmutableSet<HashCode> hashCodes =
        ImmutableSet.of(

		err = en.WriteString(zb0007)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		// map header, size 2
		// write "Bins"
		err = en.Append(0x82, 0xa4, 0x42, 0x69, 0x6e, 0x73)
		if err != nil {
			return
		}
		err = en.WriteArrayHeader(uint32(24))
		if err != nil {
			err = msgp.WrapError(err, zb0007, "Bins")
			return
		}
		for zb0009 := range zb0008.Bins {

	// write "ReplicaSize"
	err = en.Append(0x83, 0xab, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x69, 0x7a, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.ReplicaSize)
	if err != nil {
		err = msgp.WrapError(err, "ReplicaSize")
		return
	}
	// write "ReplicaCount"
	err = en.Append(0xac, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	if err != nil {
		return

    assertThat(Ints.toByteArray(0x12131415)).isEqualTo(new byte[] {0x12, 0x13, 0x14, 0x15});
    assertThat(Ints.toByteArray(0xFFEEDDCC))
        .isEqualTo(new byte[] {(byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC});
  }

  public void testFromByteArray() {
    assertThat(Ints.fromByteArray(new byte[] {0x12, 0x13, 0x14, 0x15, 0x33})).isEqualTo(0x12131415);

  public void testFromByteArray() {
    assertThat(
            Longs.fromByteArray(new byte[] {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x33}))
        .isEqualTo(0x1213141516171819L);
    assertThat(
            Longs.fromByteArray(
                new byte[] {
                  (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC,
                  (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88
                }))

   * Returns the {@code int} value whose big-endian representation is stored in the first 4 bytes of
   * {@code bytes}; equivalent to {@code ByteBuffer.wrap(bytes).getInt()}. For example, the input
   * byte array {@code {0x12, 0x13, 0x14, 0x15, 0x33}} would yield the {@code int} value {@code
   * 0x12131415}.
   *
   * <p>Arguably, it's preferable to use {@link java.nio.ByteBuffer}; that library exposes much more
   * flexibility at little cost in readability.

	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *TierConfigMgr) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "Tiers"
	err = en.Append(0x81, 0xa5, 0x54, 0x69, 0x65, 0x72, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Tiers)))
	if err != nil {
		err = msgp.WrapError(err, "Tiers")
		return
	}
	for za0001, za0002 := range z.Tiers {

		if !ok {
			t.Fatal("Unexpected error expecting 0x91")
		}
	}
	if runtime.GOOS == globalWindowsOSName {
		pathErr = &os.PathError{Err: syscall.Errno(0x03)}
		ok = isSysErrPathNotFound(pathErr)
		if !ok {
			t.Fatal("Unexpected error expecting 0x03")
		}
	}

    private static LogStream log = LogStream.getInstance();

    // KGS!@#$%
    private static final byte[] S8 = {
        (byte)0x4b, (byte)0x47, (byte)0x53, (byte)0x21,
        (byte)0x40, (byte)0x23, (byte)0x24, (byte)0x25
    };
    /* Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */

    public static final int NOT_LISTENING_CALLED = 0x80;
    public static final int NOT_LISTENING_CALLING = 0x81;
    public static final int CALLED_NOT_PRESENT = 0x82;
    public static final int NO_RESOURCES = 0x83;
    public static final int UNSPECIFIED = 0x8F;

    public int errorClass;
    public int errorCode;


    public static String getErrorString ( int errorClass, int errorCode ) {
        String result = "";