(tensor<i32>, !mlrt.promise) -> !mlrt.async_handle

  // CHECK: [[const:%.*]]  = tf_mlrt.const
  %const = "tf.Const"() {__op_key = 1: i32, value = dense<2> : tensor<i32>} : () -> tensor<i32>

  // CHECK: [[b:%.*]] = tf_mlrt.await [[futures]]
  %b = "tf_mlrt.tf_await"(%future_b) : (!mlrt.future) ->tensor<i32>

  // CHECK: [[result:%.*]] = tf_mlrt.executeop([[b]], [[const]])
  // CHECK-SAME: AddV2

string ArgView::VariableName() const { return arg_.name(); }

string ArgView::SetterMethod() const {
  if (IsList()) {
    return "AddInputList";
  } else {
    return "AddInput";
  }
}

std::vector<string> ArgView::SetterArgs() const { return {VariableName()}; }

bool ArgView::IsList() const { return arg_.arg_type().is_list(); }

int ArgView::Position() const { return arg_.position(); }

  // pass the filter (returning true) will be included.
  const llvm::SmallVector<Operation*, 4>& DirectControlPredecessors(
      Operation* op) const;
  llvm::SmallVector<Operation*, 4> DirectControlPredecessors(
      Operation* op, llvm::function_ref<bool(Operation*)> filter) const;

  // pass the filter (returning true) will be included.
  const llvm::SmallVector<Operation*, 4>& DirectControlSuccessors(

  explicit QuantizeCompositeFunctionsPass() = default;

  explicit QuantizeCompositeFunctionsPass(
      const QuantMethod quantization_method, const OpSet target_opset,
      const bool enable_per_channel_quantization,
      const int min_num_elements_for_weights,
      const bool enable_legacy_weight_only,
      std::optional<const std::string> mlir_dump_file_name)
      : enable_legacy_weight_only_(enable_legacy_weight_only),

namespace tensorflow {

Coordinator::Coordinator() : Coordinator(std::vector<error::Code>()) {}

Coordinator::Coordinator(const std::vector<error::Code>& clean_stop_errors)
    : should_stop_(false) {
  if (clean_stop_errors.empty()) {
    clean_stop_errors_.insert(error::OUT_OF_RANGE);
  } else {
    for (const auto& code : clean_stop_errors) {
      clean_stop_errors_.insert(static_cast<int>(code));
    }
  }
}

      return result;
    }
  }
  return result;
}

IsComposite IsComposite::join(const IsComposite &lhs, const IsComposite &rhs) {
  IsComposite ret;
  ret.is_on_composite_device =
      lhs.is_on_composite_device || rhs.is_on_composite_device;
  return ret;
}

void IsComposite::print(raw_ostream &os) const {
  if (is_on_composite_device) {
    os << "COMPOSITE";
  } else {
    os << "NOT_COMPOSITE";

  func.walk([&](Operation* op) {
    // TODO(renjieliu): Find a generic way to deal with const ops.
    if (op->hasTrait<OpTrait::IsTerminator>() ||
        llvm::isa<TFL::QConstOp, TFL::ConstOp>(op) ||
        llvm::isa<TFL::QConstOp, TFL::ConstOp, TF::ConstOp, ConstOp>(op))
      return;

    bool int8_type_observed = false;
    bool uint8_type_observed = false;

                    elements: VARARG type=kotlin.Array<out kotlin.Int> varargElementType=kotlin.Int
                      CONST Int type=kotlin.Int value=1
                      CONST Int type=kotlin.Int value=2
                      CONST Int type=kotlin.Int value=3
                      CONST Int type=kotlin.Int value=4
                      CONST Int type=kotlin.Int value=5

absl::StatusOr<tensorflow::quantization::ExportedModel> CreateExportedModel(
    const std::vector<std::string>& signature_keys,
    const std::unordered_set<std::string>& tags,
    const ::stablehlo::quantization::QuantizationConfig& quantization_config,
    absl::string_view debug_name_prefix,
    const absl::flat_hash_map<FunctionName, FunctionAlias>& function_aliases,

  auto main_func = module.lookupSymbol<func::FuncOp>("main");
  const TF::SideEffectAnalysis::Info& info =
      side_effect_analysis.GetAnalysisForFunc(main_func);
  llvm::StringMap<SmallVector<Cluster>> clusters = BuildAllClusters(
      main_func.front(), info, GetDevice, CanBeIgnoredInCluster);
  return clusters;
}

TEST(BuildClusters, TestSingleCluster) {
  static const char* const module_with_single_cluster =
      R"(module {