}
    }
}


inline fun <T> ReadContext.decodePreservingIdentity(decode: ReadContext.(Int) -> T): T =
    decodePreservingIdentity(isolate.identities, decode)


inline fun <T : Any> ReadContext.decodePreservingSharedIdentity(decode: ReadContext.(Int) -> T): T =
    decodePreservingIdentity(sharedIdentities) { id ->
        decode(id).also {
            sharedIdentities.putInstance(id, it)
        }
    }

        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";

                _dst.enc_ndr_string(system_name);

            }
            _dst.enc_ndr_long(access_mask);
        }
        public void decode_out(NdrBuffer _src) throws NdrException {
            handle.decode(_src);
            retval = (int)_src.dec_ndr_long();
        }
    }
    public static class SamrConnect4 extends DcerpcMessage {

        public int getOpnum() { return 0x3e; }

        public int retval;

      |-----END PRIVATE KEY-----
      |
      """.trimMargin()
    try {
      decode(certificatePem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string does not include a private key")
    }
    try {
      decode(pkcs8Pem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {

            _dst.enc_ndr_referent(netname, 1);

            if (netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(netname);

            }
        }
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);
            int _netnamep = _src.dec_ndr_long();

            if (_netnamep != 0) {
                _src = _src.deferred;

    SingletonCodec(value)


fun <T> codec(
    encode: suspend WriteContext.(T) -> Unit,
    decode: suspend ReadContext.() -> T?
): Codec<T> = object : Codec<T> {
    override suspend fun WriteContext.encode(value: T) = encode(value)
    override suspend fun ReadContext.decode(): T? = decode()
}


inline fun <reified T> IsolateContext.ownerService() =
    ownerService(T::class.java)

                ValueSupplier.ExecutionTimeValue.ofNullable(value).withSideEffect(sideEffect)
            }

            4.toByte() -> ValueSupplier.ExecutionTimeValue.changingValue<Any>(providerWithChangingValueCodec.run { decode() }!!.uncheckedCast())
            else -> throw IllegalStateException("Unexpected provider value")
        }
}


class FlowProvidersCodec(
    private val flowProviders: FlowProviders

            }
            _dst.enc_ndr_long(this.access_mask);
        }


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

    public static class SamrConnect4 extends DcerpcMessage {

        @Override
        public int getOpnum () {

    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);

    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);