return true;
    }
  }
  return false;
}

// Returns whether the current op is not supported by the TF Lite runtime.
static bool IsUnsupportedFlexOp(const std::string& op_name) {
  return op_name == "PartitionedCall" || op_name == "StatefulPartitionedCall";
}

// Create description of operation that could not be converted.
static std::string GetOpDescriptionForDebug(Operation* inst) {

       parser.parseAttribute(device, "device", result.attributes) ||
       parser.parseRParen()))
    return mlir::failure();

  if (options.has_op_name &&
      parser.parseAttribute(op_name, "op_name", result.attributes))
    return mlir::failure();

  if (options.has_symbol_ref &&
      parser.parseAttribute(f, "f", result.attributes))
    return mlir::failure();

    return "";
  }
  return std::string(entry->second);
}

string WriteClassFuzzDef(const OpInfo& op_info) {
  string class_signature_str = absl::Substitute(
      "class Fuzz$0 : public FuzzSession<$1> {\n", op_info.op_name,
      absl::StrJoin(op_info.graph_op_def.input_arg(), ", ",
                    [](string* out, const auto arg) {
                      strings::StrAppend(out, "Tensor");

        "mlir_second_phase_failed_legalization_op_count",
        "Counts which op fails to legalize", "op_name");

auto* mlir_non_static_op_count = tensorflow::monitoring::Counter<1>::New(
    "/tensorflow/core/tf2xla/"
    "mlir_second_phase_non_static_op_count",
    "Counts which ops do not have static results", "op_name");

auto* mlir_non_static_op_skip_count = tensorflow::monitoring::Counter<1>::New(
    "/tensorflow/core/tf2xla/"

    dialect_name_of_[op_with_dialect_name] = dialect_name;
    op_name_of_[op_with_dialect_name] = op_name;
    ++total_ops_;
  });
  PrintSummary();
}

void PrintOpStatsPass::CountOp(
    DenseMap<StringRef, llvm::StringMap<int64_t>> &op_count_map,
    StringRef op_name, StringRef dtype) {
  auto &op_counts = op_count_map[op_name];
  if (auto it = op_counts.find(dtype); it != op_counts.end()) {
    it->second++;
  } else {

      counted only if the ops are named 'op_name' and has 'attr_val' if
      'attr_name' is specified.
    """
    op_count = 0
    for op_name in op_names:
      # Check the main graph
      op_count += self._count_op_with_name_and_attribute(
          nodes=graphdef.node,
          op_name=op_name,
          attr_name=attr_name,
          attr_val=attr_val,

      }
    }

    return success();
  }

 private:
  // Parses TFLite Flex op's `custom_options` and returns the TF
  // `op_name` and TF dialect MLIR op attributes.
  static LogicalResult ParseCustomOption(
      StringRef custom_options, Location loc, std::string& op_name,
      SmallVectorImpl<NamedAttribute>& attributes,
      tensorflow::NodeDef& node_def) {

};

struct CostContext {
  int64_t default_unranked_tensor_size;
};

using CostFunction =
    std::function<int64_t(const CostContext&, mlir::Operation*)>;

void RegisterCostFunction(absl::string_view op_name,
                          CostFunction cost_function);

template <typename OpType, typename F>
void RegisterCostFunction(F f) {
  RegisterCostFunction(
      OpType::getOperationName().str(),

  CreateOp op = *this;
  p << "(" << op.getInCh() << ") key("
    << op->getAttrOfType<mlir::IntegerAttr>("op_key").getInt() << ") device("
    << op->getAttr("device") << ") " << op->getAttr("op_name") << "()";

  fallback_common::PrintExecuteOpCommon(p, op);
  fallback_common::PrintExecuteOpFuncAttribute(p, op);

  p << " num_args(" << op->getAttrOfType<mlir::IntegerAttr>("num_args").getInt()
    << ')';
}

    num_args: The number of inputs.
    device: The tensorflow device. eg. "/CPU:0"
    op_attrs: The tensorflow attributes excluding the func attrs.
    op_func_attrs: The func attrs.
    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      %out_ch = tfrt_fallback_async.createop(%in_ch) key(0) device("/CPU:0")