if (projectComponentId.getBuild().equals(thisBuild)) {
                resolvedProjectConfigurations.add(new ResolvedProjectConfiguration(projectComponentId.getIdentityPath(), node.getMetadata().getName()));
            }
        }
    }

    /**
     * Mark all configurations corresponding to visited project variant nodes as observed.
     */

    protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {
        Class<?> clazz = findClass(name);
        if (resolve) {
          resolveClass(clazz);
        }
        return clazz;
      }

      return super.loadClass(name, resolve);
    }

            throw new DuplicateParameterException(parameter.getName()
                    + " has been declared multiple times in mojo with goal: " + getGoal() + " (implementation: "
                    + getImplementation() + ")");
        }

        parameters.add(parameter);
    }

    /**
     * @return the list parameters as a Map (keyed by {@link Parameter#getName()}) that is built from

        sb.append("   Cannot select module with conflict on ");
        Capability capability = capabilityConflict.left;
        sb.append("capability '").append(capability.getGroup()).append(":").append(capability.getName()).append(":").append(capability.getVersion()).append("' also provided by ");
        sb.append(capabilityConflict.getRight());
        return sb.toString();
    }

    @Override

        }
    }

    @Override
    protected DependencyReportModel calculateReportModelFor(Project project) {
        SortedSet<Configuration> sortedConfigurations = new TreeSet<>(Comparator.comparing(Configuration::getName));
        sortedConfigurations.addAll(getReportConfigurations());
        List<ConfigurationDetails> configurationDetails = new ArrayList<>(sortedConfigurations.size());

        rootComponent.addNode(this.root);
        ComponentVariantNodeIdentifier rootNodeId = new ComponentVariantNodeIdentifier(componentId, rootVariant.getName());
        nodes.put(rootNodeId, this.root);
    }

    public ComponentIdGenerator getIdGenerator() {
        return idGenerator;
    }

    public ResolutionConflictTracker getConflictTracker() {

			// malformed label error
			log.Errorf("%s/%s, has a malformed %s label, value found: %s", meta.GetNamespace(), meta.GetName(), constants.AmbientUseWaypointLabel, labelValue)
			return nil, false
		}

	}
	return nil, false
}

func (w Waypoint) ResourceName() string {
	return w.GetNamespace() + "/" + w.GetName()
}

func WaypointsCollection(
	Gateways krt.Collection[*v1beta1.Gateway],

      new Ordering<Invokable<?, ?>>() {
        @Override
        public int compare(Invokable<?, ?> left, Invokable<?, ?> right) {
          return left.getName().compareTo(right.getName());
        }
      };

  private static final Ordering<Invokable<?, ?>> BY_PARAMETERS =
      new Ordering<Invokable<?, ?>>() {
        @Override

      new Ordering<Invokable<?, ?>>() {
        @Override
        public int compare(Invokable<?, ?> left, Invokable<?, ?> right) {
          return left.getName().compareTo(right.getName());
        }
      };

  private static final Ordering<Invokable<?, ?>> BY_PARAMETERS =
      new Ordering<Invokable<?, ?>>() {
        @Override

  if (!module) {
    LOG(ERROR) << "Couldn't import flatbuffer to MLIR.";
    return kTfLiteError;
  }

  // Apply quantization passes.
  PassManager pm((*module)->getName(), OpPassManager::Nesting::Implicit);
  if (debug_options.has_value()) {
    // Add debugging instrumentation
    tensorflow::InitPassManager(pm, debug_options.value());
  }
  quant::QuantizationSpecs quant_specs;