Queues:           128,
						HandSize:         6,
						QueueLengthLimit: 50,
					},
				},
			},
		})
)

// Suggested FlowSchema objects.
// Ordered by matching precedence, so that their interactions are easier
// to follow while reading this source.
var (
	// the following flow schema exempts probes
	SuggestedFlowSchemaProbes = newFlowSchema(
		"probes", "exempt", 2,

	// List of code and resource suppressions to exclude messages on
	suppressions []AnalysisSuppression

	// Mesh config for this analyzer. This can come from multiple sources, and the last added version will take precedence.
	meshCfg *v1alpha1.MeshConfig

	// Mesh networks config for this analyzer.
	meshNetworks *v1alpha1.MeshNetworks

	// Which kube resources are used by this analyzer

// `QuantizationSpec`s so that specs can be easily passed around or represented
// as a textproto.
// Next ID: 2
message QuantizationSpecs {
  // List of `QuantizationSpec`s. Later spec in the sequence takes precedence.
  //
  // NOTE: Tie-breaking mechanism is not yet supported. Providing multiple
  // `QuantizationSpec` with conflicting quantizable units may result in
  // undefined behavior.

     * <pre class='autoTested'>
     * repositories {
     *     mavenLocal()
     * }
     * </pre>
     * <p>
     * The location for the repository is determined as follows (in order of precedence):
     * </p>
     * <ol>
     * <li>The value of system property 'maven.repo.local' if set;</li>

	// For pods, we enqueue all Ingress if its part of the ingress service
	c.pods.AddEventHandler(controllers.ObjectHandler(func(o controllers.Object) {
		if c.meshConfig.Mesh().IngressService != "" {
			// Ingress Service takes precedence
			return
		}
		ingressSelector := c.meshConfig.Mesh().IngressSelector

		// get all pods acting as ingress gateways
		igSelector := getIngressGatewaySelector(ingressSelector, "")

		}
		return args[i].Name < args[j].Name
	})
	return args
}

// convertFromArgs takes a slice of arguments and returns an argument map.
// Duplicate argument keys will be de-duped, where later keys will take precedence.
func convertFromArgs(in []kubeadm.Arg) map[string]string {
	if in == nil {
		return nil
	}
	args := make(map[string]string, len(in))
	for _, arg := range in {
		args[arg.Name] = arg.Value
	}

Use of wildcards that overlap within the same resource list or across multiple
entries are not allowed since part of the configuration would be ineffective.
Resource lists are processed in order, with earlier lists taking precedence.

Example:

	kind: EncryptionConfiguration
	apiVersion: apiserver.config.k8s.io/v1
	resources:
	- resources:
	  - events
	  providers:

func (mux *serveMux121) handler(host, path string) (h Handler, pattern string) {
	mux.mu.RLock()
	defer mux.mu.RUnlock()

	// Host-specific pattern takes precedence over generic ones
	if mux.hosts {
		h, pattern = mux.match(host + path)
	}
	if h == nil {
		h, pattern = mux.match(path)
	}
	if h == nil {
		h, pattern = NotFoundHandler(), ""
	}
	return
}

		} else if provider.ID(ni.Registry) != provider.Kubernetes {
			// 2 possible cases:
			// 1. If the SE has multiple addresses(vips) specified, merge the ips
			// 2. If the previous SE is a decorator of the k8s service, give precedence to the k8s service
			if svc.Attributes.ServiceRegistry == provider.Kubernetes {
				ni.Ips = addressList
				ni.Registry = string(provider.Kubernetes)

            val incDecPrecedence = when (psi) {
                is KtPostfixExpression -> KaCompoundAccess.IncOrDecOperation.Precedence.POSTFIX
                else -> KaCompoundAccess.IncOrDecOperation.Precedence.PREFIX
            }
            val incOrDecOperationKind = psi.getInOrDecOperationKind()
            val baseExpression = deparenthesize(psi.baseExpression)