name = "BOOLEAN",
      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 1L,
      codec =
        object : BasicDerAdapter.Codec<Boolean> {
          override fun decode(reader: DerReader): Boolean = reader.readBoolean()

          override fun encode(
            writer: DerWriter,
            value: Boolean,
          ) = writer.writeBoolean(value)
        },
    )

  val INTEGER_AS_LONG =
    BasicDerAdapter(

func (d *Decoder) Pos() int { return int(d.pos) }

// Err returns the most recent decoder error if any, or nil
func (d *Decoder) Err() error { return d.err }

// MaxDepth will set the maximum recursion depth.
// If the maximum depth is exceeded, ErrMaxDepth is returned.
// Less than or 0 means no limit (default).
func (d *Decoder) MaxDepth(n int) *Decoder {
	d.maxDepth = n
	return d
}

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

                    this.info = new DfsEnumStruct();
                }
                this.info.decode(_src);

            }
            int _totalentriesp = _src.dec_ndr_long();
            if ( _totalentriesp != 0 ) {
                this.totalentries.decode(_src);

            }
            this.retval = _src.dec_ndr_long();
        }
    }

        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.sid, 1);

            if ( this.sid != null ) {
                _dst = _dst.deferred;
                this.sid.encode(_dst);

            }
        }


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

                if (info == null) { /* YOYOYO */
                    info = new DfsEnumStruct();
                }
                info.decode(_src);

            }
            int _totalentriesp = _src.dec_ndr_long();
            if (_totalentriesp != 0) {
                totalentries.decode(_src);

            }
            retval = (int)_src.dec_ndr_long();
        }
    }

        public String netname;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _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);

        public rpc.sid_t sid;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(sid, 1);

            if (sid != null) {
                _dst = _dst.deferred;
                sid.encode(_dst);

            }
        }
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);

        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.netname, 1);

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

            }
        }


        @Override
        public void decode ( NdrBuffer _src ) 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);