// details.
bool IsImportLocPattern(FusedLoc loc) {
  ArrayRef<Location> locations = mlir::cast<FusedLoc>(loc).getLocations();
  if (locations.size() < 2 || !isa<NameLoc>(locations.front())) return false;

  StringRef op_type_with_suffix =
      mlir::cast<NameLoc>(locations.front()).getName().strref();
  if (!op_type_with_suffix.ends_with(":")) return false;

  return absl::c_all_of(locations, [](Location loc) {
    return isa<NameLoc>(loc) ||

    id("gradlebuild.publish-public-libraries")
}

description = """Persistent caches on disk and cross process locking.
    | Mostly for persisting Maps to the disk.
    | Also contains implementations for in-memory caches in front of the disk cache.
""".trimMargin()

dependencies {
    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)
    api(project(":build-operations"))

			// This is the EOF symbol. Because it's always at the
			// end of the move-to-front list, and never gets moved
			// to the front, it has this unique value.
			break
		}

		// Since two metasymbols (RUNA and RUNB) have values 0 and 1,
		// one would expect |v-2| to be passed to the MTF decoder.
		// However, the front of the MTF list is never referenced as 0,
		// it's always referenced with a run-length of 1. Thus 0

          new_while_op.getBody().front().getNumArguments());
      for (auto i : args_to_erase) body_bit_vector.set(i);
      new_while_op.getBody().front().eraseArguments(body_bit_vector);
      llvm::BitVector cond_bit_vector(
          new_while_op.getCond().front().getNumArguments());
      for (auto i : args_to_erase) cond_bit_vector.set(i);
      new_while_op.getCond().front().eraseArguments(cond_bit_vector);

  ASSERT_TRUE(module_op);

  ASSERT_FALSE(module_op->getBodyRegion().empty());
  ASSERT_FALSE(module_op->getBodyRegion().front().empty());

  auto constant_op = dyn_cast_or_null<mlir::stablehlo::ConstantOp>(
      module_op->getBodyRegion().front().front());
  ASSERT_THAT(constant_op, NotNull());

  EXPECT_TRUE(HasRankOf(constant_op, /*rank=*/4));
}

              device_cluster, &if_op.getThenBranch().front(),
              {host_if.getThenBranch().front().getTerminator()},
              core_to_compilation_key, core_to_device_ordinal,
              /*control_above=*/true, is_map_oc, communication_key_index)))
        return WalkResult::interrupt();
      if (failed(MoveToHostMultiCluster(
              device_cluster, &if_op.getElseBranch().front(),

ArgView OpView::OnlyInput() const {
  CHECK_EQ(input_args_.size(), 1);  // Crash OK
  return input_args_.front();
}

ArgView OpView::OnlyOutput() const {
  CHECK_EQ(output_args_.size(), 1);  // Crash OK
  return output_args_.front();
}

string OpView::FunctionName() const { return op_.name(); }

string OpView::OpNameString() const { return Quoted(op_.name()); }

  }

  auto element_type = getElementTypeOrSelf(first_operand_type);
  if (mlir::isa<TF::ResourceType>(element_type)) {
    first_operand_type =
        mlir::cast<TF::ResourceType>(element_type).getSubtypes().front();
  }

  auto tensor_type = mlir::dyn_cast_or_null<TensorType>(first_operand_type);
  if (!(tensor_type && tensor_type.hasRank())) {
    return op->emitError()

    // Add terminator of tf_executor::graph
    rewriter.setInsertionPointToEnd(&executor_graph.getBody().front());
    rewriter.create<tf_executor::FetchOp>(loc);

    // Add terminator of func
    rewriter.setInsertionPointToEnd(&func.getBody().front());
    rewriter.create<func::ReturnOp>(loc);

    rewriter.replaceOp(graph.getOperation(), func.getOperation()->getResults());

// CPU.
LogicalResult IsCpuRead(FuncOp func, ReadVariableOp read, bool& is_cpu_read) {
  if (auto arg = mlir::dyn_cast<BlockArgument>(read->getOperand(0))) {
    if (arg.getOwner() != &(func.front())) {
      is_cpu_read = false;
      return success();
    }
    if (auto attr = func.getArgAttrOfType<StringAttr>(arg.getArgNumber(),
                                                      kFuncDeviceAttr)) {