private void setNegotiatedFlags2(SmbComNegotiateResponse response, int flags2) {
        try {
            Field field = response.getClass().getDeclaredField("negotiatedFlags2");
            field.setAccessible(true);
            field.set(response, flags2);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set negotiatedFlags2 field", e);
        }

        // Verify that the constructor correctly sets ptype and flags
        // These values are inherited from LsarClose, but MsrpcLsarClose sets them in its constructor
        assertEquals(0, msrpcLsarClose.getPtype(), "ptype should be 0");
        assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, msrpcLsarClose.getFlags(),
                "flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

            assertEquals(100L, t.delay, "Default delay should be 100");
        }

        @Test
        @DisplayName("Multiple flags are parsed correctly")
        void multipleFlags() {
            TestLocking t = new TestLocking();

            // Parse multiple flags
            String[] args = { "-t", "3", "-i", "7", "-d", "200", "smb://test/file.txt" };
            for (int ai = 0; ai < args.length; ai++) {

func MaskFromMaskable(m Maskable) Mask {
	return Mask(m.Mask())
}

// Contains returns whether *all* flags in other is present in t.
func (t Mask) Contains(other Mask) bool {
	return t&other == other
}

// Overlaps returns whether *any* flags in t overlaps with other.
func (t Mask) Overlaps(other Mask) bool {
	return t&other != 0
}

// SingleType returns whether t has a single type set.

        @Nullable Inet4Address server, @Nullable Inet4Address client, int port, int flags) {
      checkArgument(
          (port >= 0) && (port <= 0xffff), "port '%s' is out of range (0 <= port <= 0xffff)", port);
      checkArgument(
          (flags >= 0) && (flags <= 0xffff),
          "flags '%s' is out of range (0 <= flags <= 0xffff)",
          flags);

      this.server = MoreObjects.firstNonNull(server, ANY4);

        dataOffset += 8;
        
        // Flags (4 bytes)
        int flags = 0;
        if (cacheScope == DirectoryCacheScope.RECURSIVE_TREE) {
            flags |= DIRECTORY_LEASE_FLAG_RECURSIVE;
        }
        if (notificationEnabled) {
            flags |= DIRECTORY_LEASE_FLAG_NOTIFICATIONS;
        }
        writeInt4(buffer, dataOffset, flags);
        dataOffset += 4;
        

### Sync/Async Replication

By default, replication is completed asynchronously. If synchronous replication is desired, set the --sync flag while adding a
remote replication target using the `mc admin bucket remote add` command. For mc releases on or after `RELEASE.2022-12-24T15-21-38Z`, the 
--sync, --health-check and --bandwidth flags can be specified in `mc replicate add|update` command

```

		if e != nil {
			e = msgp.WrapError(e, "Flags")
			return o, e
		}
		z.Flags = zb0003
	}
	o = bts
	return o, e
}

func (z xlMetaV2VersionHeaderV2) MarshalJSON() (o []byte, e error) {
	tmp := struct {
		VersionID string
		ModTime   time.Time
		Signature string
		Type      uint8
		Flags     uint8
	}{
		VersionID: hex.EncodeToString(z.VersionID[:]),

	"github.com/minio/pkg/v3/console"
	"github.com/minio/pkg/v3/env"
	"github.com/minio/pkg/v3/trie"
	"github.com/minio/pkg/v3/words"
)

// GlobalFlags - global flags for minio.
var GlobalFlags = []cli.Flag{
	// Deprecated flag, so its hidden now - existing deployments will keep working.
	cli.StringFlag{
		Name:   "config-dir, C",
		Value:  defaultConfigDir.Get(),

                + ",maxParameterCount=" + maxParameterCount + ",maxDataCount=" + maxDataCount + ",maxSetupCount=" + (int) maxSetupCount
                + ",flags=0x" + Hexdump.toHexString(flags, 2) + ",timeout=" + timeout + ",parameterCount=" + parameterCount
                + ",parameterOffset=" + parameterOffset + ",parameterDisplacement=" + parameterDisplacement + ",dataCount=" + dataCount