/**
     * Time encoding type: 1970 epoch, 32-bit seconds, big-endian.
     */
    public static final int TIME_1970_SEC_32BE = 1;

    /**
     * Time encoding type: 1970 epoch, 32-bit seconds, little-endian.
     */
    public static final int TIME_1970_SEC_32LE = 2;

    /**
     * Time encoding type: 1904 epoch, 32-bit seconds, big-endian.
     */
    public static final int TIME_1904_SEC_32BE = 3;

            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_RESERVED_1), "DCERPC_RESERVED_1 should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_CONC_MPX), "DCERPC_CONC_MPX should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_DID_NOT_EXECUTE), "DCERPC_DID_NOT_EXECUTE should be a single bit");

   * most key spaces are ANYTHING BUT uniformly distributed. A bit(i) in the input is said to
   * 'affect' a bit(j) in the output if two inputs, identical but for bit(i), will differ at output
   * bit(j) about half the time
   *
   * <p>Funneling is pretty simple to detect. The key idea is to find example keys which
   * unequivocally demonstrate that funneling cannot be occurring. This is done bit-by-bit. For each

    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */
    public static final int ACB_MNS = 32;
    /** Account control bit flag: Interdomain trust account */
    public static final int ACB_DOMTRUST = 64;
    /** Account control bit flag: Workstation trust account */
    public static final int ACB_WSTRUST = 128;

    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */
    public static final int ACB_MNS = 32;
    /** Account control bit flag: Interdomain trust account */
    public static final int ACB_DOMTRUST = 64;
    /** Account control bit flag: Workstation trust account */
    public static final int ACB_WSTRUST = 128;

        @DisplayName("Should validate constant bit positions")
        void shouldHaveCorrectBitPositions() {
            // Verify specific bit positions as documented in comments
            assertEquals(0, Integer.numberOfTrailingZeros(ACE.FILE_READ_DATA), "FILE_READ_DATA should be at bit position 0");
            assertEquals(1, Integer.numberOfTrailingZeros(ACE.FILE_WRITE_DATA), "FILE_WRITE_DATA should be at bit position 1");

)

// uint8 is the set of all unsigned 8-bit integers.
// Range: 0 through 255.
type uint8 uint8

// uint16 is the set of all unsigned 16-bit integers.
// Range: 0 through 65535.
type uint16 uint16

// uint32 is the set of all unsigned 32-bit integers.
// Range: 0 through 4294967295.
type uint32 uint32

// uint64 is the set of all unsigned 64-bit integers.
// Range: 0 through 18446744073709551615.

        packet.type = SessionServicePacket.SESSION_MESSAGE;
        packet.trailerLength = 0x10000; // Length requiring extended bit

        byte[] dst = new byte[100];
        packet.writeWireFormat(dst, 0);

        assertEquals((byte) 0x01, dst[1]); // Extended length bit should be set
    }

    @Test
    @DisplayName("readWireFormat should read header and trailer")

    }

    /*
     * Encode and decode 64 bit integers
     */

    /**
     * Encodes a 64-bit unsigned integer in big-endian byte order.
     *
     * @param l the long value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (8)
     */

not <code>3&amp;(1&lt;&lt;2)</code>.
Also, constants are always evaluated as 64-bit unsigned integers.
Thus <code>-2</code> is not the integer value minus two,
but the unsigned 64-bit integer with the same bit pattern.
The distinction rarely matters but
to avoid ambiguity, division or right shift where the right operand's
high bit is set is rejected.
</p>

<h3 id="symbols">Symbols</h3>

<p>