MOVW	R1, R0<<0(F1)      // ERROR "illegal base register"
	MOVB	R2, R0<<0(F1)      // ERROR "illegal base register"
	MOVF	0x00ffffff(F2), F1 // ERROR "illegal base register"
	MOVD	0x00ffffff(F2), F1 // ERROR "illegal base register"
	MOVF	F2, 0x00ffffff(F2) // ERROR "illegal base register"
	MOVD	F2, 0x00ffffff(F2) // ERROR "illegal base register"
	MULS.S	R1, R2, R3, R4     // ERROR "invalid .S suffix"

  @Override
  <E extends Comparable<E>> ImmutableSortedSet.Builder<E> builder() {
    return ImmutableSortedSet.naturalOrder();
  }

  @Override
  int getComplexBuilderSetLastElement() {
    return 0x00FFFFFF;
  }

  public void testLegacyComparable_of() {
    ImmutableSortedSet<LegacyComparable> set0 = ImmutableSortedSet.of();
    assertThat(set0).isEmpty();

        }

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")
    void testReadInt2() {
        byte[] src = { (byte) 0x12, (byte) 0x34, (byte) 0x56 };

        right ^= work;
        leftt ^= work << 4;

        work = (leftt >>> 16 ^ right) & 0x0000ffff;
        right ^= work;
        leftt ^= work << 16;

        work = (right >>> 2 ^ leftt) & 0x33333333;
        leftt ^= work;
        right ^= work << 2;

        work = (right >>> 8 ^ leftt) & 0x00ff00ff;
        leftt ^= work;
        right ^= work << 8;
        right = right << 1 | right >>> 31 & 1;

        // Test with max int value (unsigned interpretation)
        buffer.putInt(0, 0xFFFFFFFF);
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should read max ULong correctly.");

        // Test with a negative int (should be interpreted as unsigned positive)
        buffer.putInt(0, -1); // -1 is 0xFFFFFFFF
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should interpret -1 as unsigned max ULong.");
    }

        SMBUtil.writeInt2(16, buffer, 0);
        buffer[2] = (byte) 0xFF; // Max share type
        buffer[3] = 0;
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 4); // Max share flags
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 8); // Max capabilities
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 12); // Max access

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then

        DataOutputStream dos = new DataOutputStream(baos);

        // Write the special "never" FILETIME value
        writeLittleEndianInt(dos, 0xffffffff);
        writeLittleEndianInt(dos, 0x7fffffff);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        PacDataInputStream pacStream = new PacDataInputStream(bais);

    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.write(headerBlock, Http2.INITIAL_MAX_FRAME_SIZE.toLong())

    // Write the continuation frame, specifying no more frames are expected.
    writeMedium(frame, headerBlock.size.toInt())
    frame.writeByte(Http2.TYPE_CONTINUATION)
    frame.writeByte(FLAG_END_HEADERS)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeAll(headerBlock)

    void testWriteSetupWireFormatBufferBoundary() {
        notifyChange = new NtTransNotifyChange(mockConfig, 0xFFFF, 0xFFFFFFFF, true);
        byte[] dst = new byte[8]; // Exact size needed

        int bytesWritten = notifyChange.writeSetupWireFormat(dst, 0);

        assertEquals(8, bytesWritten);
        assertEquals(0xFFFFFFFF, SMBUtil.readInt4(dst, 0));
        assertEquals(0xFFFF, SMBUtil.readInt2(dst, 4));