return v > 0
	}
	// On ID mismatch
	if v := bytes.Compare(x.VersionID[:], o.VersionID[:]); v != 0 {
		return v > 0
	}
	// Flags
	if x.Flags != o.Flags {
		return x.Flags > o.Flags
	}
	return false
}

func (j xlMetaV2Version) getDataDir() string {
	if j.Valid() {
		switch j.Type {
		case LegacyType:
			return j.ObjectV1.DataDir

	// as UTF-8, they will need to set the flag bit themselves.
	utf8Valid1, utf8Require1 := detectUTF8(fh.Name)
	utf8Valid2, utf8Require2 := detectUTF8(fh.Comment)
	switch {
	case fh.NonUTF8:
		fh.Flags &^= 0x800
	case (utf8Require1 || utf8Require2) && (utf8Valid1 && utf8Valid2):
		fh.Flags |= 0x800
	}

                ACE.FLAGS_INHERITED })
        @DisplayName("Flag constants should be powers of 2")
        void shouldBeValidFlagPowersOfTwo(int flag) {
            assertTrue(flag > 0, "Flag should be positive");
            assertEquals(0, flag & (flag - 1), "Flag should be power of 2: " + Integer.toHexString(flag));
        }

        @Test
        @DisplayName("Should validate all constants are unique")

    return new JdkMatcher(pattern.matcher(t));
  }

  @Override
  public String pattern() {
    return pattern.pattern();
  }

  @Override
  public int flags() {
    return pattern.flags();
  }

  @Override
  public String toString() {
    return pattern.toString();
  }

  private static final class JdkMatcher extends CommonMatcher {
    final Matcher matcher;

// this behavior.
func adminMiddleware(f http.HandlerFunc, flags ...hFlag) http.HandlerFunc {
	// Collect all flags with bitwise-OR and assign operator
	var handlerFlags hFlag
	for _, flag := range flags {
		handlerFlags |= flag
	}

	// Get name of the handler using reflection.
	handlerName := getHandlerName(f, "adminAPIHandlers")

	var handler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {

        @DisplayName("Should set SMB2_FLAGS_SIGNED flag")
        void testSignSetsSignedFlag() {
            // Set initial flags without signed flag
            int initialFlags = 0x00000001;
            SMBUtil.writeInt4(initialFlags, data, 16);

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

            int flags = SMBUtil.readInt4(data, 16);

    /**
     * Opens an input stream reading the file (read only)
     *
     * @param flags
     *            open flags
     * @param access
     *            desired access flags
     * @param sharing
     *            flags indicating for which operations others may open the file (FILE_SHARING_*)
     * @return input stream, needs to be closed when finished

    bazel by doing as follows:

    ```bash
    export flags="--config=linux -k"
    ```

    If the tests are to be run on the GPU:

    *   For TensorFlow versions starting from v.2.18.0: Add the `cuda` option
        flag.

        ```bash
        export flags="--config=linux --config=cuda -k"
        ```

     * @param tc the CIFS context to use
     * @param flags resolution flags
     * @return the members of the group
     * @throws IOException if there is an error retrieving group members
     */
    public jcifs.SID[] getGroupMemberSids(final String authorityServerName, final CIFSContext tc, final int flags) throws IOException {
        if (this.type != SID_TYPE_DOM_GRP && this.type != SID_TYPE_ALIAS) {

        }

        /**
         * DFS flags
         */
        public int flags;
        /**
         * The DFS name
         */
        public String dfs_name;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(flags);
            _dst.enc_ndr_referent(dfs_name, 1);