if (!device_type_.hasValue()) return;
  auto func_op = getOperation();

  auto walk_result = func_op->walk([&](TF::StatelessRandomGetAlgOp op) {
    if (failed(ConvertGetAlgOp(op))) {
      op->emitOpError(
          "Could not convert and remove Device specific information");
      return WalkResult::interrupt();
    }

    return WalkResult::advance();
  });

        mlir::cast<FlatSymbolRefAttr>(sym_ref).getValue());

    if (!init_func_op)
      return session_initializer.emitOpError()
             << "the initializer function does not exist";

    if (!init_func_op.getFunctionType().getResults().empty())
      return session_initializer.emitOpError()
             << "the initializer function should have no output";

    auto exported_names = GetExportedNames(init_func_op);

      auto ret = func.front().getTerminator();
      auto block_arg =
          mlir::dyn_cast<BlockArgument>(ret->getOperand(result_idx));
      if (!block_arg) {
        return op->emitOpError("result #")
               << result_idx << " not tied to function argument for branch @"
               << func.getName();
      }
      if (!common_arg_index.has_value()) {

      }
      if (axis < 0 || (input_type.hasRank() && axis >= input_type.getRank())) {
        return transpose_op.emitOpError("perm must be in [-rank, rank)");
      }
      if (std::count(axes.begin(), axes.end(), axis) > 0) {
        return transpose_op.emitOpError("perm cannot have duplicated axis");
      }
      axes.push_back(axis);
    }

  if (failed(tensorflow::GetDevicesFromOp(moduleOp, &devices)))
    return moduleOp.emitOpError() << "No available devices.";
  llvm::ArrayRef<tensorflow::DeviceNameUtils::ParsedName> device_names =
      devices.device_names();
  auto status_or_system_devices = GetTPUSystemDevices(device_names);
  if (!status_or_system_devices.ok())
    return moduleOp.emitOpError()
           << "error in fetching TPU_SYSTEM devices: "

            existing_resource->getName().getStringRef() ||
        resource_op->getResult(0).getType() !=
            existing_resource->getResult(0).getType()) {
      resource_op->emitOpError(
          "This op has the same `shared_name` but different type with another "
          "resource op in the function");
      signalPassFailure();
      return;
    }

    tf_device::ClusterOp tpu_cluster = pair.second;
    if (node_to_cluster.count(node)) {
      if (node_to_cluster[node].getOperation() != tpu_cluster) {
        node->getCallableRegion()->getParentOp()->emitOpError(
            "The same function is reachable from multiple TPU Clusters.");
      }
    } else {
      node_to_cluster[node] = tpu_cluster;
      auto result = node->getCallableRegion()->walk([&](Operation* op) {

  if (!ranked_type)
    return context_op->emitOpError()
           << "A map_outside_compilation op's input and output types must be "
              "ranked tensors.";
  ArrayRef<int64_t> in_shape = ranked_type.getShape();
  if (in_shape.empty() || in_shape[0] < 0) {
    return context_op->emitOpError()
           << "A map_outside_compilation op's input and output shapes must "

                          cast<CallableOpInterface>(called_func.getOperation()),
                          called_func.getCallableRegion(),
                          /* shouldCloneInlinedRegion = */ false))) {
      call_op.emitOpError() << "Failed to inline\n";
      return WalkResult::interrupt();
    }
    called_func.erase();
    call_op.erase();
    return WalkResult::advance();
  });

  if (!num_cores_per_replica_attr)
    return cluster_func.emitOpError(
        CreateMissingAttributeMsg(tensorflow::kNumCoresPerReplicaAttr));

  int num_cores_per_replica = num_cores_per_replica_attr.getInt();

  auto topology_attr =
      cluster_func->getAttrOfType<StringAttr>(tensorflow::kTopologyAttr);
  if (!topology_attr)
    return cluster_func.emitOpError(
        CreateMissingAttributeMsg(tensorflow::kTopologyAttr));