DuplicateShapeDeterminingConstantsPass)

  StringRef getArgument() const final {
    return "quant-duplicate-shape-determining-constants";
  }

  StringRef getDescription() const final {
    return "Duplicates shape-determining constants. A shape-determining "
           "constant is a constant that are transitively used to change or "
           "determine the shape of a tensor. For example, the second argument "

@Experimental
public interface DependencyResolver extends Service {

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph. Note that this operation is
     * only concerned about determining the coordinates of the transitive dependencies and does not actually resolve the
     * artifact files.
     *
     * @param session the {@link Session}, must not be {@code null}

package org.gradle.internal.problems.failure;

import javax.annotation.Nullable;

/**
 * Classifies stack frames by their {@link StackTraceRelevance relevance}.
 * <p>
 * Classifiers are meant to be heuristic, determining the relevance on the best-effort basis.
 */
public interface StackTraceClassifier {

    StackTraceClassifier USER_CODE = new StackTraceClassifier() {
        @Override

//   1) Inserting the @main function, which will become the main Graph.
//   2) Duplicating shape-determining constants.
//   3) Converting TF dialect -> tf_executor dialect.
//   4) Adding initializer function's ops into @main function for correct
//      resource initialization when loading the exported model.
//
// Duplicating shape-determining constants is required to place constants that

import javax.annotation.Nullable;
import java.util.Collection;

/**
 * Represents the request context a client has made.
 *
 * This contains the list of properties a client will consider when determining if a daemon is compatible.
 */
public class DaemonRequestContext {
    private final JavaInfo requestedJvm;
    private final DaemonJvmCriteria jvmCriteria;
    private final Collection<String> daemonOpts;

        this.delegate = delegate;
    }

    @Override
    public UpToDateResult execute(UnitOfWork work, C context) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Determining if {} is up-to-date", work.getDisplayName());
        }
        ImmutableList<String> reasons = context.getRebuildReasons();
        return context.getChanges()
            .filter(__ -> reasons.isEmpty())

	// Generate a port map from the matching services.
	// It creates a structure that will allow us to detect
	// if there are different protocols for the same port.
	portMap := servicePortMap(matchingSvcs)

	// Determining which ports use more than one protocol.
	for port := range portMap {
		// In case there are two protocols using same port number, generate a message
		protMap := portMap[port]
		if len(protMap) > 1 {

		xKey, err := cache.MetaNamespaceKeyFunc(x)
		if err != nil {
			tCtx.Fatalf("unexpected error determining key for %v: %v", x, err)
		}
		yKey, err := cache.MetaNamespaceKeyFunc(y)
		if err != nil {
			tCtx.Fatalf("unexpected error determining key for %v: %v", y, err)
		}
		return xKey < yKey
	}))
	if diff != "" {

  // attribute.
  pm.addNestedPass<func::FuncOp>(createInsertWeightParamPass());

  // PrepareQuantizePass uses SymbolTable to fetch relevant GEMM ops for
  // determining quantization attributes. This requires module-level context.
  pm.addPass(createPrepareQuantizePass(options));

  QuantizePassOptions quantize_options;
  quantize_options.enable_per_channel_quantized_weight_ =

import org.gradle.plugin.use.PluginId;
import org.gradle.plugin.use.tracker.internal.PluginVersionTracker;

import javax.annotation.Nullable;

/**
 * Resolves a plugin either by determining that it is already on the classpath
 * or by delegating to another resolver.
 */
public class AlreadyOnClasspathPluginResolver implements PluginResolver {
    private final PluginResolver delegate;