if (!type || !type.getElementType().isF32()) return quantizable_ops;

    const Value value = op.getResult();

    for (OpOperand& use : value.getUses()) {
      Operation* user = use.getOwner();
      const int operand_num = use.getOperandNumber();
      quantizable_ops.insert({user, operand_num});
    }
    return quantizable_ops;
  }

            MethodSpec spec = MethodSpec.methodBuilder(implementation.getName())
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .addParameter(typeName(callable.getOwner().getType()), SELF_PARAMETER_NAME)
                .addParameters(parameters)
                .addCode(generateMethodBody(implementation, callable, implementationExtra))

      old_partitioned_input.get_XlaShardingAttr().getValue().str());
  for (OpOperand& read_use :
       llvm::make_early_inc_range(old_read.getValue().getUses())) {
    if (dyn_cast_or_null<tf_device::ClusterFuncOp>(read_use.getOwner())) {
      // ClusterFunc's use of the Read is replaced with use of the
      // TPUPartitionedInputV2.
      read_use.set(new_partitioned_input);
    } else {

// one). If there are no activation functions that use the output, returns
// nullptr.
Operation *GetActivation(Value op) {
  for (auto &use : op.getUses()) {
    if (IsActivationFunction(use.getOwner())) return use.getOwner();
  }
  return nullptr;
}

// Finds and returns a BiasAdd that uses the result of `op` as the `value`
// input. If there are multiple such BiasAdds, one is returned (with no

  if (auto arg = source.dyn_cast<BlockArgument *>()) {
    auto range = llvm::make_filter_range(arg->getUsers(), [&](Operation *user) {
      bool same_block = user->getBlock() == arg->getOwner();
      return same_block && state.IsMember(user);
    });
    return {range.begin(), range.end()};
  }

  llvm_unreachable("Unexpected type in the union.");
}

  for (IslandOp new_op : islands) {
    for (Value result : new_op.getOutputs()) {
      if (llvm::any_of(result.getUsers(), [&](OpOperand user) {
            return !wrapped_ops.count(user.getOwner());
          }))
        result_types.push_back(result.getType());
    }
  }

  IslandOp new_island = OpBuilder(island).create<IslandOp>(
      island.getLoc(), result_types,

        ImmutableModuleIdentifierFactory moduleIdentifierFactory
    ) {
        ResolvedVariantResult variant = edge.getResolvedVariant();
        ComponentIdentifier componentId = variant.getOwner();

        // TODO #3170: We should analyze artifacts to determine if we need to publish additional
        // artifact information like type or classifier.

// SELinux.
func (hu *HostUtil) GetSELinuxSupport(pathname string) (bool, error) {
	return GetSELinux(pathname, procMountInfoPath, selinux.GetEnabled)
}

// GetOwner returns the integer ID for the user and group of the given path
func (hu *HostUtil) GetOwner(pathname string) (int64, int64, error) {
	realpath, err := filepath.EvalSymlinks(pathname)
	if err != nil {
		return -1, -1, err
	}
	return GetOwnerLinux(realpath)
}

        moduleDependencyBuilder = new ModuleDependencyBuilder(artifactRegistry);
        currentProjectId = project.getOwner().getComponentIdentifier();
        optimizer = new IdeaDependenciesOptimizer();
        this.gradleApiSourcesResolver = gradleApiSourcesResolver;
    }

    public Set<Dependency> provide(final IdeaModule ideaModule) {

    Value value = op.getResult();

    // Check whether dynamic range quantization can be applied.
    for (auto& use : value.getUses()) {
      Operation* user = use.getOwner();
      int operand_num = use.getOperandNumber();
      std::unique_ptr<OpQuantSpec> spec = GetTFOpQuantSpec(user);

      if (quant_specs_.inference_type == tensorflow::DT_QINT8 &&