* @return whether the specified mechanism is supported
     */
    boolean isSupported ( ASN1ObjectIdentifier mechanism );


    /**
     * @param selectedMech
     * @return whether the specified mechanism is preferred
     */
    boolean isPreferredMech ( ASN1ObjectIdentifier selectedMech );


    /**
     * @return context flags
     */
    int getFlags ();


    /**

class SaveQuantizationReportInstrumentation : public PassInstrumentation {
 public:
  // `file_path` is the path to save the report file. The report file is in
  // textproto format so a `.txtpb` extension is preferred but it doesn't result
  // in error if other extension is used. This instrumentation will not be run
  // if `file_path` is a `nullopt`.
  explicit SaveQuantizationReportInstrumentation(

        }
    }

    /**
     * For all modules providing a capability, always use the preferred module, even if there's no conflict.
     * In other words, will forcefully upgrade all modules providing a capability to a selected module.
     *
     * @param to the preferred module
     */
    private
    fun ConfigurationContainer.forceUpgrade(to: String, version: String) = all {

            }
            if (version.requires != null) {
                write("requires", version.requires);
            }
            if (version.preferred != null) {
                write("prefers", version.preferred);
            }
            if (!version.rejectedVersions.isEmpty()) {
                writeArray("rejects", version.rejectedVersions);
            }
        });
    }

		"Example: '30000-32767'. Inclusive at both ends of the range.")

	// Kubelet related flags:
	fs.StringSliceVar(&s.KubeletConfig.PreferredAddressTypes, "kubelet-preferred-address-types", s.KubeletConfig.PreferredAddressTypes,
		"List of the preferred NodeAddressTypes to use for kubelet connections.")

	fs.UintVar(&s.KubeletConfig.Port, "kubelet-port", s.KubeletConfig.Port,
		"DEPRECATED: kubelet port.")

	}
}

// preferReaders can mark readers as preferred.
// These will be chosen before others.
func (p *parallelReader) preferReaders(prefer []bool) {
	if len(prefer) != len(p.orgReaders) {
		return
	}
	// Copy so we don't change our input.
	tmp := make([]io.ReaderAt, len(p.orgReaders))
	copy(tmp, p.orgReaders)
	p.readers = tmp
	// next is the next non-preferred index.
	next := 0
	for i, ok := range prefer {

    def factory = new InetAddressFactory()
    InetAddresses addresses = Mock()

    def setup() {
        factory.inetAddresses = addresses
    }

    def "Loopback addresses are preferred"() {
        when:
        def loopback = [ip(127, 0, 0, 1)]
        loopbackAddresses(loopback)
        remoteAddresses([ip(192, 168, 17, 256)])

        then:
        factory.communicationAddresses == loopback

  virtual absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> Import() = 0;
};

// Interface for exporting a module.
// Users should implement the interface for exporting the result from TAC
// in their preferred way.
// See TacModule in how to register it with the module and use it.
class TacExporter {
 public:
  virtual ~TacExporter() = default;

  // Imports and returns the Module for the imported program.

{
  "components": {
    "schemas": {
      "io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup": {
        "description": "APIGroup contains the name, the supported versions, and the preferred version of a group.",
        "properties": {
          "apiVersion": {

	// Not required for ambient, so disabled by default
	PreferHBONESend = registerAmbient(
		"PILOT_PREFER_SENDING_HBONE",
		false, false,
		"If enabled, HBONE will be preferred when sending to destinations. ")

	DefaultAllowFromWaypoint = registerAmbient(
		"PILOT_AUTO_ALLOW_WAYPOINT_POLICY",
		false, false,