}

SmallVector<Value> CloneOpWithReplacedOperands(
    OpBuilder& builder, Operation* op, const ArrayRef<Value> new_operands) {
  IRMapping mapping;
  for (const auto& arg : enumerate(new_operands)) {
    mapping.map(op->getOperand(arg.index()), arg.value());
  }
  return builder.clone(*op, mapping)->getResults();
}

FailureOr<int32_t> CastI64ToI32(const int64_t value) {

      function.getNumArguments() - var_handle_shared_names.size();
  int new_argument_index = 0;
  llvm::SmallVector<int, 4> argument_indices_to_remove;
  for (auto resource_and_index : llvm::enumerate(resources)) {
    const auto& resource = resource_and_index.value();
    if (!resource.live_value) {
      // Ignore non resource arguments.
      ++new_argument_index;
      continue;
    }

 *
 * <h2>Relationship with Java compiler standard location</h2>
 * This enumeration is closely related to the {@link JavaFileManager.Location} enumerations.
 * A difference is that the latter enumerates input and output files, while {@code JavaPathType}
 * enumerates only input dependencies. Another difference is that {@code JavaPathType} contains
 * some enumeration values used only at runtime and therefore not available in {@code javax.tool},

    return "runs passes registered as tensorflow::GraphOptimizationPass";
  }

 private:
  void runOnOperation() override {
    // Verify all passes requested were registered/found.
    for (auto pass_it : llvm::enumerate(passes_)) {
      if (pass_it.value() == nullptr) {
        mlir::emitError(mlir::UnknownLoc::get(&getContext()))
            << "could not find pass " << cl_pass_list[pass_it.index()];
        return signalPassFailure();

          contracting_dims.add(c)
      x_signature = [
          None if c not in contracting_dims else x_shape[cidx]
          for cidx, c in enumerate(x_labels)
      ]
      y_signature = [
          None if c not in contracting_dims else y_shape[cidx]
          for cidx, c in enumerate(y_labels)
      ]
    return x_shape, y_shape, bias_shape, x_signature, y_signature

  def _create_einsum_model(
      self,

              // filter.
              return a_is_function_exclude > b_is_function_exclude;
            });

  for (const auto& tac_filter : llvm::enumerate(tac_filters_->tac_filters())) {
    SmallVector<Operation*> filtered_ops;
    ApplyTacFilter(module, tac_filter.value(), filtered_ops, builder);
    PrintTacFilterResult(module.getLoc(), tac_filter.value(),

      llvm::SmallDenseMap<Value, int> outputs_replaced;
      SmallVector<Type, 4> output_types;
      output_types.reserve(quantizing_op->getNumResults());
      for (const auto& enumerated_result :
           llvm::enumerate(quantizing_op->getResults())) {
        Value result = enumerated_result.value();
        Type result_type = result.getType();
        if (result_type.isa<NoneType>()) {

  tpu_devices.reserve(system_devices.size());

  auto lookup = [&devices](ParsedDevice device_spec) {
    device_spec.has_type = true;
    device_spec.type = kDeviceTPU;
    // Enumerate all the available TPUs.
    device_spec.has_id = false;

    llvm::SmallVector<ParsedDevice, 8> host_tpu_devices =
        FindMatchingDevices(devices, device_spec);

    // Sort devices by id.

  for (int i = 0; i < op->getNumRegions(); ++i) {
    state.addRegion();
  }
  Operation* new_op = builder.create(state);
  for (const auto& indexed_regions : llvm::enumerate(op->getRegions())) {
    Region& region = op->getRegion(indexed_regions.index());
    IRMapping mapping;
    indexed_regions.value().cloneInto(&region, mapping);
  }
  int new_position = 0;

      case_op.getIsStateless(), case_op.getBranches().size());
  CopyDeviceAndUnderscoredAttributes(case_op, case_region);

  for (const auto& item : llvm::enumerate(case_region.getBranches())) {
    CreateCall(case_op, case_op.branch_function(item.index()),
               /*caller_region=*/item.value(), case_op.getInput(),
               /*use_region_args=*/false,