// Fold Arithmetic Op if one of the operands is a constant known to be an
// Identity (e.g. X+0, X*1, etc...). For commutative operations fold if
// known identity value is either lhs or rhs.
template <
    typename OpT,
    typename std::enable_if<llvm::is_one_of<
        OpT, AddV2Op, SubOp, MulOp, DivOp, RealDivOp>::value>::type * = nullptr>
OpFoldResult IdentityArithmeticOpFolder(OpT arithmetic_op,

constexpr char kOkStatus[] = "ok";
const int kArbitraryIntResult = 37;

template <typename T>
tsl::StatusOr<T> success(T t) {
  return t;
}
absl::StatusOr<int> success() { return kArbitraryIntResult; }
template <typename T>
tsl::StatusOr<T> filtered(T t) {
  return tsl::StatusOr<T>(tensorflow::CompileToHloGraphAnalysisFailedError());
}

    : public impl::QuantConvertSimulatedQuantBase<ConvertSimulatedQuantPass> {
  void runOnOperation() override;
};

/// Base class rewrites ConstFakeQuant into a qbarrier/dbarrier pair.
template <typename ConcreteRewriteClass, typename FakeQuantOp>
class FakeQuantRewrite : public OpRewritePattern<FakeQuantOp> {
 public:
  using OpRewritePattern<FakeQuantOp>::OpRewritePattern;

  FakeQuantRewrite(MLIRContext *ctx, bool *hadFailure)

                          CostFunction cost_function) {
  auto r = registry.try_emplace(op_name, std::move(cost_function));
  assert(r.second);
  (void)r;
}

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

	i.mu.RLock()
	defer i.mu.RUnlock()
	log.Errorf("> BEGIN DUMP (index %v[%T])", i.c.(internalCollection[I]).name(), ptr.TypeName[K]())
	for k, v := range i.objects {
		log.Errorf("key %v: %v", k, v.UnsortedList())
	}
	log.Errorf("< END DUMP (index %v[%T]", i.c.(internalCollection[I]).name(), ptr.TypeName[K]())
}

// NewNamespaceIndex is a small helper to index a collection by namespace

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

ArgTypeView::ArgTypeView(ArgType arg_type) : arg_type_(arg_type) {}

string ArgTypeView::TypeName() const {
  if (arg_type_.is_read_only()) {
    if (arg_type_.is_list()) {
      return "absl::Span<AbstractTensorHandle* const>";
    } else {
      return "AbstractTensorHandle* const";
    }
  } else {

// `default_value`.
template <typename T>
static inline std::vector<T> GetOptionalVector(
    std::optional<ArrayRef<T>> values, int64_t default_size = 0,
    int64_t default_value = 0) {
  if (values.has_value()) {
    return std::vector<T>(values->begin(), values->end());
  }
  return std::vector<T>(default_size, default_value);
}

template <typename T>
static inline std::vector<T> GetVector(

tensorflow::DataType GetQuantizedInferenceType(bool is_signed,
                                               int activation_number_of_bits);

// Returns the element type of LSTM's intermediate tensor designated by the
// index.
template <typename LstmOp>
inline QuantizedType GetIntermediateElementType(LstmOp op, int tensor_index) {
  if (tensor_index < 0 || tensor_index > 4) return nullptr;
  TypeAttr attr = op->template getAttrOfType<TypeAttr>(

    }
  }

 private:
  /// @brief A utility class for mapping C++ types to Type values.
  template <typename T>
  struct EnumValueOf;

  /// @brief A utility class for accessing the `Data` union members.
  template <typename T>
  struct UnionAccess;

  // Unsafe Move, because it assumes the union has already been destroyed
  // or is new!

        // We assume different types won't ever produce identical display names
        if (reportedValueSources.add(displayName ?: typeName)) {
            reportValueSourceInput(trace, displayName, typeName)
        }
    }

    private
    fun reportValueSourceInput(trace: PropertyTrace, displayName: String?, typeName: String) {