namespace tracing {

Status MaybeSetOpName(AbstractOperation* op, const char* op_name) {
  if (isa<TracingOperation>(op)) {
    TF_RETURN_IF_ERROR(dyn_cast<TracingOperation>(op)->SetOpName(op_name));
  }
  if (isa<gradients::TapeOperation>(op)) {
    TF_RETURN_IF_ERROR(MaybeSetOpName(
        dyn_cast<gradients::TapeOperation>(op)->GetBackingOperation(),
        op_name));
  }
  return absl::OkStatus();
}
}  // namespace tracing

using tensorflow::OpRegistrationData;
using tensorflow::OpRegistry;
using tensorflow::Status;

namespace {

void Register(const std::string& op_name, OpRegistry* registry) {
  registry->Register([op_name](OpRegistrationData* op_reg_data) -> Status {
    op_reg_data->op_def.set_name(op_name);
    return absl::OkStatus();
  });
}

}  // namespace

TEST(TfTextUtilsTest, TestTfTextRegistered) {

}

}  // namespace

void RegisterCostFunction(absl::string_view op_name,
                          CostFunction cost_function) {
  RegisterCostFunction(GetCostFunctionRegistry(), op_name,
                       std::move(cost_function));
}

bool HasCostFunctionRegistered(absl::string_view op_name) {
  return GetCostFunctionRegistry().contains(op_name);
}

int64_t CostAnalysis::GetCost(mlir::Operation* op) const {

    "/tensorflow/core/tf2xla/v1/mlir_failed_xla_legalize_tf_count",
    "Counts the attempts of legalization of ops", "op_name");

auto *mlir_failed_legalization_count = tensorflow::monitoring::Counter<2>::New(
    "/tensorflow/core/tf2xla/v1/mlir_failed_xla_legalize_tf_pass_count",
    "Counts the failure of legalization of ops", "op_name", "legality");

class LegalizeTF : public impl::LegalizeTFBase<LegalizeTF> {
 public:

  getOperation()->walk([&](Operation *op) {
    auto dialect_name = op->getDialect()->getNamespace();
    auto op_name = op->getName().stripDialect();
    if (IsAcceptedOp(dialect_name, op_name, accepted_dialects_)) {
      // If given op is in the `accepted_dialects_`, it's ok.
    } else if (IsAcceptedOp(dialect_name, op_name,
                            optional_accepted_dialects_)) {

  const string mul_op_name = linear.GetUniqueNameForOp("mul");
  const string bias_add_op_name = linear.GetUniqueNameForOp("bias_add");
  auto cop_names = AnotherCompositeOp(cop_scopes.last);
  return {mul_op_name, bias_add_op_name, cop_names[0], cop_names[1],
          cop_names[2]};
}

}  // namespace

TEST(ScopeTest, CompositeOp) {
  Scope root = Scope::NewRootScope();
  const auto names1 = LinearOp(root);

  bool IsAssertOrCheckNumerics(absl::string_view op_name) const {
    return op_name == "Assert" || op_name == "CheckNumerics";
  }

  bool IsStatefulRandomOp(absl::string_view op_name) const {
    return op_name == "RandomUniform" || op_name == "RandomShuffle" ||
           op_name == "RandomUniformInt" || op_name == "RandomStandardNormal" ||
           op_name == "TruncatedNormal" || op_name == "Multinomial";
  }

  string c_decl;
  for (int i = 0; i < op_info.arg_types.size(); ++i) {
    if (i > 0) strings::StrAppend(&c_decl, ", ");
    strings::StrAppend(&c_decl, op_info.arg_types[i], " ",
                       op_info.arg_names[i]);
  }
  if (include_attr && op_info.has_optional_attrs) {
    strings::StrAppend(&c_decl, ", const ", op_info.op_name, "::Attrs& attrs");
  }

    op_names_.assign((*argv) + 1, (*argv) + (*argc));
  }

  generator::cpp::CppConfig CppConfig() {
    return generator::cpp::CppConfig(category_);
  }

  generator::PathConfig PathConfig() {
    return generator::PathConfig(output_dir_, source_dir_, api_dirs_,
                                 op_names_);
  }

 private:
  std::vector<tensorflow::Flag> Flags() {

  bool IsAllowListedOp(Operation *op) {
    std::string op_name = op->getName().getStringRef().str();
    if (IsAlwaysAllowlistedOp(op) || IsTfFakeQuantOp(op)) {
      return true;
    } else if (mode_ == kDefaultMode) {
      return QuantizableOpsInDefaultMode().count(op_name) > 0;
    } else if (mode_ == kLegacyIntegerMode) {
      return QuantizableOpsInLegacyMode().count(op_name) > 0;
    } else {