if bits&(1<<lo) != 0 {
					p.errorf("register R%d already in list", lo)
				}
				bits |= 1 << lo
				lo++
			}
		default:
			p.errorf("unexpected register list")
		}
		if p.peek() != ']' {
			p.get(',')
		}
	}
	a.Type = obj.TYPE_REGLIST
	switch p.arch.Family {
	case sys.ARM:
		a.Offset = int64(bits)
	case sys.ARM64:

    @Override
    public HashCode hashBytes(byte[] input, int off, int len) {
      return HashCode.fromBytes(Arrays.copyOfRange(input, off, off + len));
    }

    @Override
    public int bits() {
      throw new UnsupportedOperationException();
    }
  }

    }

    @Test
    void testPtypeAndFlagsValues() {
        // Verify specific flag values are correctly set
        assertEquals(0, msrpcShareGetInfo.getPtype());

        // Check individual flag bits
        int flags = msrpcShareGetInfo.getFlags();
        assertTrue((flags & DcerpcConstants.DCERPC_FIRST_FRAG) != 0);
        assertTrue((flags & DcerpcConstants.DCERPC_LAST_FRAG) != 0);
    }

    @Test

}

// Forked from Golang but chooses to avoid performing lookup
//
// osMkdirAll creates a directory named path,
// along with any necessary parents, and returns nil,
// or else returns an error.
// The permission bits perm (before umask) are used for all
// directories that MkdirAll creates.
// If path is already a directory, MkdirAll does nothing
// and returns nil.
func osMkdirAll(dirPath string, perm os.FileMode, baseDir string) error {

En Python 3.10 también hay una **nueva sintaxis** donde puedes poner los posibles tipos separados por una <abbr title='también llamado "operador OR a nivel de bits", pero ese significado no es relevante aquí'>barra vertical (`|`)</abbr>.

//// tab | Python 3.10+

```Python hl_lines="1"
{!> ../../docs_src/python_types/tutorial008b_py310.py!}
```

////

import jcifs.internal.smb2.io.Smb2ReadRequest;
import jcifs.internal.smb2.io.Smb2ReadResponse;
import jcifs.util.transport.TransportException;

/**
 * This InputStream can read bytes from a file on an SMB file server. Offsets are 64 bits.
 */
public class SmbFileInputStream extends InputStream {

    private static final Logger log = LoggerFactory.getLogger(SmbFileInputStream.class);

    private SmbFileHandleImpl handle;
    private long fp;

                Arguments.of(FILE_NOTIFY_CHANGE_ALL, "All changes"), Arguments.of(0x00000000, "No filters"),
                Arguments.of(0xFFFFFFFF, "All bits set"));
    }

    @ParameterizedTest
    @DisplayName("Test writeSetupWireFormat with different watchTree values")
    @CsvSource({ "true, 0x01", "false, 0x00" })

func (z *Int) Bytes() []byte {
	b := make([]byte, (z.Len()+7)/8)
	n := C.size_t(len(b))
	C.mpz_export(unsafe.Pointer(&b[0]), &n, 1, 1, 1, 0, &z.i[0])
	return b[0:n]
}

// Len returns the length of z in bits.  0 is considered to have length 1.
func (z *Int) Len() int {
	z.doinit()
	return int(C.mpz_sizeinbase(&z.i[0], 2))
}

// Set sets z = x and returns z.
func (z *Int) Set(x *Int) *Int {
	z.doinit()

        long[] testValues = { 0L, // Zero
                1L, // One
                -1L, // Negative one
                0x00000000FFFFFFFFL, // 32-bit max as long
                0xFFFFFFFF00000000L, // High 32 bits set
                0x7FFFFFFFFFFFFFFFL, // Long.MAX_VALUE
                0x8000000000000000L, // Long.MIN_VALUE
                0x0101010101010101L, // Repeating pattern
                0xFEFEFEFEFEFEFEFEL // Another pattern

        assertTrue(str.contains(specialRemark));
    }

    @Test
    @DisplayName("Test type masking with 0xFFFF")
    void testTypeMasking() {
        // Test that only lower 16 bits are considered for type determination
        int typeWithUpperBits = 0xFFFF0001; // Should be treated as type 1 (printer)
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, typeWithUpperBits, TEST_REMARK);