}


        @Override
        public void encode_in ( NdrBuffer _dst ) throws NdrException {
            this.handle.encode(_dst);
            _dst.enc_ndr_long(this.access_mask);
            this.sid.encode(_dst);
        }


        @Override
        public void decode_out ( NdrBuffer _src ) throws NdrException {
            this.domain_handle.decode(_src);
            this.retval = _src.dec_ndr_long();

        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        return stream(getGroups()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    private String decode(final String value) {
        return new String(Base64.getDecoder().decode(value), Constants.CHARSET_UTF_8);
    }

    @Override

            this.count = count;
        }

        public void encode_in(NdrBuffer _dst) throws NdrException {
            handle.encode(_dst);
            sids.encode(_dst);
            names.encode(_dst);
            _dst.enc_ndr_short(level);
            _dst.enc_ndr_long(count);
        }
        public void decode_out(NdrBuffer _src) throws NdrException {
            int _domainsp = _src.dec_ndr_long();

    assertThat(UnsignedLongs.decode("0xffffffffffffffff")).isEqualTo(0xffffffffffffffffL);
    assertThat(UnsignedLongs.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedLongs.decode("#1234567890abcdef")).isEqualTo(0x1234567890abcdefL);
    assertThat(UnsignedLongs.decode("987654321012345678")).isEqualTo(987654321012345678L);
    assertThat(UnsignedLongs.decode("0x135791357913579")).isEqualTo(0x135791357913579L);

        }


        @Override
        public void encode_in ( NdrBuffer _dst ) throws NdrException {
            this.handle.encode(_dst);
            this.sids.encode(_dst);
            this.names.encode(_dst);
            _dst.enc_ndr_short(this.level);
            _dst.enc_ndr_long(this.count);
        }


        @Override
        public void decode_out ( NdrBuffer _src ) throws NdrException {

  } catch (nsee: NoSuchElementException) {
    throw IllegalArgumentException("failed to decode certificate", nsee)
  } catch (iae: IllegalArgumentException) {
    throw IllegalArgumentException("failed to decode certificate", iae)
  } catch (e: GeneralSecurityException) {
    throw IllegalArgumentException("failed to decode certificate", e)
  }
}

/**
 * Returns the certificate encoded in [PEM format][rfc_7468].
 *

        Mac m = Mac.getInstance("HmacMD5");
        m.init(new SecretKeySpec(Hex.decode(key), "HMAC"));
        byte[] mac = m.doFinal(bytes);
        checkBytes(Hex.decode(expect), mac);
    }


    @Test
    public void testRC4Checksum1 () throws PACDecodingException, GeneralSecurityException {
        String data = "fifteen sixteen";

	v := BucketReplicationStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBucketReplicationStat Msgsize() is inaccurate")
	}

	vn := BucketReplicationStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)

            result = buf.dec_ndr_long();
        } else {                        /* Bind_ack or Response */
            decode_out(buf);
        }
    }

    public abstract int getOpnum();
    public abstract void encode_in(NdrBuffer buf) throws NdrException;
    public abstract void decode_out(NdrBuffer buf) throws NdrException;

    assertThat(UnsignedInts.decode("0xffffffff")).isEqualTo(0xffffffff);
    assertThat(UnsignedInts.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedInts.decode("#12345678")).isEqualTo(0x12345678);
    assertThat(UnsignedInts.decode("76543210")).isEqualTo(76543210);
    assertThat(UnsignedInts.decode("0x13579135")).isEqualTo(0x13579135);
    assertThat(UnsignedInts.decode("0X13579135")).isEqualTo(0x13579135);