}

    /**
     * Decodes a double value from little-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded double value
     */
    public static double dec_doublele(final byte[] src, final int si) {
        return Double.longBitsToDouble(dec_uint64le(src, si));
    }

    /**

    }

    /**
     * Decodes a double value from little-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded double value
     */
    public static double dec_doublele(final byte[] src, final int si) {
        return Double.longBitsToDouble(dec_uint64le(src, si));
    }

    /**

                notifications.add(notification);
            }
        }
    }

    /**
     * Decodes a single notification from the NDR buffer.
     *
     * @param buf the NDR buffer
     * @return the decoded notification
     * @throws NdrException if decoding fails
     */
    private WitnessNotificationResponse decodeNotification(NdrBuffer buf) throws NdrException {

	set    bool
	Unused struct{} // Needed for GOB compatibility
}

// UnmarshalXML - decodes XML data.
func (p *Prefix) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	var s string
	if err = d.DecodeElement(&s, &start); err != nil {
		return err
	}
	*p = Prefix{string: s, set: true}
	return nil
}

// MarshalXML - decodes XML data.
func (p Prefix) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {

	if filter.isEmpty() {
		return nil
	}
	type filterRuleWrapper FilterRule
	return e.EncodeElement(filterRuleWrapper(filter), start)
}

// UnmarshalXML - decodes XML data.
func (filter *FilterRule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().
	type filterRule FilterRule
	rule := filterRule{}
	if err := d.DecodeElement(&rule, &start); err != nil {

        buffer.append("=");
        return buffer.toString();
    }

    /**
     * Decodes the supplied Base-64 encoded string.
     *
     * @param string The Base-64 encoded string that is to be decoded.
     * @return A <code>byte[]</code> containing the decoded data block.
     */
    public static byte[] decode(final String string) {
        final int length = string.length();
        if (length == 0) {

        }
    }

    /**
     * Decodes a string from UTF-16LE (Unicode Little Endian) bytes.
     *
     * @param src the byte array containing the encoded string
     * @param srcIndex the starting offset in the byte array
     * @param len the number of bytes to decode
     * @return decoded string
     */

    }

    /**
     * Encodes a small integer (1 byte) in NDR format.
     *
     * @param s the small integer value to encode
     */
    public void enc_ndr_small(final int s) {
        this.buf[this.index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */

    }

    /**
     * Encodes a small integer (1 byte) in NDR format.
     *
     * @param s the small integer value to encode
     */
    public void enc_ndr_small(final int s) {
        buf[index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */

    }

    /**
     * Decodes data encoded in Base64.
     * <p>
     * This method uses {@link java.util.Base64.Decoder} for decoding.
     * </p>
     *
     * @param inData
     *            The data to decode
     * @return The decoded data, or null if the input is null or empty
     */
    public static byte[] decode(final String inData) {
        if (StringUtil.isEmpty(inData)) {