// Arrange
        byte[] buffer = new byte[10];
        SMBUtil.writeInt2(200, buffer, 0);
        // These bytes should be ignored
        buffer[2] = (byte) 0xFF;
        buffer[3] = (byte) 0xFF;
        SMBUtil.writeInt2(TransPeekNamedPipeResponse.STATUS_LISTENING, buffer, 4);

        // Act
        int result = response.readParametersWireFormat(buffer, 0, 6);

        // Assert

			fields: fields{
				value: []byte("3e5"),
			},
			want:   0,
			wantOK: false,
		},
		{
			// No support for prefixes
			name: "hex",
			fields: fields{
				value: []byte("0xff"),
			},
			want:   0,
			wantOK: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			v := &Value{
				value: tt.fields.value,
			}

	SUBS	$0xff, R6, RSP                                   // ERROR "illegal destination register"
	SUBS	$0xffff0, R6, RSP                                // ERROR "illegal destination register"
	SUBS	$0x1000100010001000, R6, RSP                     // ERROR "illegal destination register"
	SUBS	$0x10001000100011, R6, RSP                       // ERROR "illegal destination register"

        writeInt2(fid, dst, dstIndex);
        dstIndex += 2;
        writeInt4(offset, dst, dstIndex);
        dstIndex += 4;
        for (int i = 0; i < 4; i++) {
            dst[dstIndex++] = (byte) 0xFF;
        }
        writeInt2(writeMode, dst, dstIndex);
        dstIndex += 2;
        writeInt2(remaining, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00;
        dstIndex++;

	MOVW	$0xff, R9            // MOVW $255, R9             // ff90a0e3
	MOVW	$0xff000000, R9      // MOVW $4278190080, R9      // ff94a0e3
	MOVW	$0xff(R0), R1        // MOVW $255(R0), R1         // ff1080e2
	MOVW.S	$0xff(R0), R1        // MOVW.S $255(R0), R1       // ff1090e2
	MOVW	$-0xff(R0), R1       // MOVW $-255(R0), R1        // ff1040e2
	MOVW.S	$-0xff(R0), R1       // MOVW.S $-255(R0), R1      // ff1050e2

        void testSignZeroesSignatureField() {
            // Fill signature field with non-zero values
            for (int i = 0; i < SIGNATURE_LENGTH; i++) {
                data[SIGNATURE_OFFSET + i] = (byte) 0xFF;
            }

            digest.sign(data, 0, data.length, request, response);

            // Verify signature field contains actual signature (not all zeros)

        byte[] h = new byte[4];
        h[0] = (byte) SessionServicePacket.SESSION_MESSAGE;
        h[1] = (byte) ((length >> 16) & 0x01);
        h[2] = (byte) ((length >> 8) & 0xFF);
        h[3] = (byte) (length & 0xFF);
        return h;
    }

    /**
     * Creates a NetBIOS keep-alive header.
     * Keep-alive packets have type 0x85 and zero length.
     */
    private static byte[] keepAliveHeader() {

            // Manually verify the encoded bytes
            assertEquals(buffer.size(), bytesEncoded);

            // Check referral level (little-endian)
            assertEquals(4, dst[0] & 0xFF);
            assertEquals(0, dst[1] & 0xFF);

            // Check path starts at byte 2
            byte[] expectedPathBytes = path.getBytes(StandardCharsets.UTF_16LE);
            byte[] actualPathBytes = new byte[expectedPathBytes.length];

        byte[] buffer = new byte[512];
        // Fill buffer with non-zero values to ensure padding writes zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        int written = trans2SetFileInfo.writeDataWireFormat(buffer, 0);

        // Should report 26 bytes written (20 from encode + 6 increment)
        assertEquals(26, written);

        // Test with data length exactly matching outputBuffer size
        byte[] testData = new byte[outputBuffer.length];
        Arrays.fill(testData, (byte) 0xFF);
        byte[] buffer = new byte[outputBuffer.length + 100];
        System.arraycopy(testData, 0, buffer, 0, outputBuffer.length);

        int result = response.readDataWireFormat(buffer, 0, outputBuffer.length);