- any: true
        principals:
        - andIds:
            ids:
            - any: true
      ns[foo]-policy[httpbin-deny]-rule[3]:
        permissions:
        - andRules:
            rules:
            - any: true
        principals:
        - andIds:
            ids:
            - orIds:
                ids:
                - authenticated:
                    principalName:

	n, err = getgroups(n, &a[0])
	if err != nil {
		return nil, err
	}
	gids = make([]int, n)
	for i, v := range a[0:n] {
		gids[i] = int(v)
	}
	return
}

func Setgroups(gids []int) (err error) {
	if len(gids) == 0 {
		return setgroups(0, nil)
	}

	a := make([]_Gid_t, len(gids))
	for i, v := range gids {
		a[i] = _Gid_t(v)
	}
	return setgroups(len(a), &a[0])
}

	for _, id := range ids {
		for _, info := range d {
			if info.NUMANodeID == id {
				coreIDs = append(coreIDs, info.CoreID)
			}
		}
	}
	return cpuset.New(coreIDs...)
}

// CoresInSockets returns all of the core IDs associated with the given socket
// IDs in this CPUDetails.
func (d CPUDetails) CoresInSockets(ids ...int) cpuset.CPUSet {
	var coreIDs []int
	for _, id := range ids {
		for _, info := range d {

            - orIds:
                ids:
                - remoteIp:
                    addressPrefix: 10.99.10.8
                    prefixLen: 32
                - remoteIp:
                    addressPrefix: 10.80.64.0
                    prefixLen: 18
        - andIds:
            ids:
            - orIds:
                ids:
                - authenticated:

        } else {
            entry = vertex;
        }

        MetadataTreeNode[] kids = node.getChildren();
        if (kids == null || kids.length < 1) {
            return;
        }

        for (int i = 0; i < kids.length; i++) {
            MetadataTreeNode n = kids[i];
            processTreeNodes(vertex, n, depth + 1, i);
        }
    }

                      - stringMatch:
                          safeRegex:
                            regex: .+
        principals:
        - andIds:
            ids:
            - orIds:
                ids:
                - authenticated:
                    principalName:
                      exact: spiffe://principal
                - authenticated:
                    principalName:

        principals:
        - andIds:
            ids:
            - any: true
      ns[foo]-policy[httpbin-4]-rule[0]:
        permissions:
        - andRules:
            rules:
            - orRules:
                rules:
                - destinationPort: 80
                - destinationPort: 90
        principals:
        - andIds:
            ids:
            - any: true

  std::vector<std::string> ids{"1"};
  std::vector<int32_t> calibration_methods{
      CalibrationOptions::CALIBRATION_METHOD_AVERAGE_MIN_MAX};

  std::vector<NodeDefBuilder::NodeOut> inputs;
  inputs.emplace_back("min", 0, DT_FLOAT);
  inputs.emplace_back("max", 0, DT_FLOAT);

  TF_CHECK_OK(NodeDefBuilder("op", "CalibrationStatisticsSaver")
                  .Input(inputs)
                  .Attr("ids", ids)

            - orIds:
                ids:
                - remoteIp:
                    addressPrefix: 10.99.10.8
                    prefixLen: 32
                - remoteIp:
                    addressPrefix: 10.80.64.0
                    prefixLen: 18
        - andIds:
            ids:
            - orIds:
                ids:
                - authenticated:

	if len(keyUsages) == 0 {
		keyUsages = []ExtKeyUsage{ExtKeyUsageServerAuth}
	}
	oids := make([]*byte, 0, len(keyUsages))
	for _, eku := range keyUsages {
		if eku == ExtKeyUsageAny {
			oids = nil
			break
		}
		if oid, ok := windowsExtKeyUsageOIDs[eku]; ok {
			oids = append(oids, &oid[0])
		}
	}
	if oids != nil {
		para.RequestedUsage.Type = syscall.USAGE_MATCH_TYPE_OR