attr = cst.getValue();
  } else if (auto cst = dyn_cast<tfl::QConstOp>(inst)) {
    attr = cst.getValue();
  } else if (auto cst = dyn_cast<mlir::stablehlo::ConstantOp>(inst)) {
    attr = cst.getValue();
  } else if (auto cst = dyn_cast<mlir::vhlo::ConstantOpV1>(inst)) {
    mlir::VhloToStablehloTypeConverter vhlo_type_converter;

                                    const OperatorT& quant_op, int idx) {
  const auto& builtin_code =
      GetBuiltinCode(quant_model.operator_codes[quant_op.opcode_index].get());
  for (const auto& expected_op : expected_graph.operators) {
    const auto& op_code =
        expected_model.operator_codes[expected_op->opcode_index].get();
    const auto& expected_code = GetBuiltinCode(op_code);
    if (expected_code == builtin_code) {

}

void Exporter::UseOriginalFunctionNames(NodeDef& node_def) {
  if (!configs_.export_original_tf_func_name) return;

  auto& attrs = *node_def.mutable_attr();

  auto try_use_original_func_name = [this](std::string* name) {
    if (auto func = symbol_table_.lookup<FuncOp>(*name)) {
      if (auto original_func_name =
              func->getAttrOfType<mlir::StringAttr>("tf._original_func_name")) {

       subgraph_idx++) {
    const auto quantized_graph = output_model->subgraphs()->Get(subgraph_idx);
    const auto float_graph = model_->subgraphs()->Get(subgraph_idx);
    ASSERT_EQ(quantized_graph->tensors()->size(),
              float_graph->tensors()->size());
    std::vector<int> used_tensors;
    for (size_t i = 0; i < quantized_graph->tensors()->size(); i++) {
      const auto quant_tensor = quantized_graph->tensors()->Get(i);

    auto guard = OpBuilder::InsertionGuard(*rewriter);
    auto inputs = branch_func.getFunctionType().getInputs();
    Block *block = rewriter->createBlock(
        &branch_func.getBody(), branch_func.begin(), inputs,
        SmallVector<Location>(inputs.size(), branch_func.getLoc()));

    auto input_shape = block->getArgument(1);
    auto size_diff = block->getArgument(2);

  mlir::MLIRContext context(registry);
  auto module = mlir::OwningOpRef<mlir::ModuleOp>(
      mlir::parseSourceString<mlir::ModuleOp>(kMLIR, &context));
  auto module_op = module.get();
  auto serialized_result_fb = ExportRuntimeMetadata(module_op);
  const auto* result = GetRuntimeMetadata(serialized_result_fb.value().c_str());
  const auto* expected = GetRuntimeMetadata(kExpectedFB.c_str());

// resolved
LogicalResult PrecheckForXlaConvV2Op(XlaConvV2Op op) {
  auto input_tensor = op.getLhs();
  auto kernel_tensor = op.getRhs();
  auto window_strides = op.getWindowStrides();
  auto padding = op.getPadding();
  auto lhs_dilation = op.getLhsDilation();
  auto rhs_dilation = op.getRhsDilation();
  auto feature_group_count = op.getFeatureGroupCount();
  int64_t batch_group_count = op.getBatchGroupCount();

  auto output_fbm = tflite::FlatBufferModel::BuildFromBuffer(
      reinterpret_cast<const char*>(output_builder.GetCurrentBufferPointer()),
      output_builder.GetSize());
  tflite::ModelT output_model;
  output_fbm->GetModel()->UnPackTo(&output_model);

  // Extract output metadata
  std::map<std::string, std::string> output_metadata;
  for (const auto& metadata : output_model.metadata) {

    Location loc = op.getLoc();
    auto params = op.getParams();
    auto params_ty = mlir::dyn_cast<RankedTensorType>(params.getType());
    auto indices = op.getIndices();
    auto indices_ty = mlir::dyn_cast<RankedTensorType>(indices.getType());
    auto params_rank = params_ty.getRank();
    auto indices_rank = indices_ty.getRank();

    //   ...
    // }
    auto ret = f.getBody().front().getTerminator();
    std::vector<Type> argument_types;
    for (auto arg : f.getBody().front().getArguments()) {
      argument_types.push_back(arg.getType());
    }
    std::vector<Type> return_types;
    for (auto ret_op : ret->getOperands()) {
      return_types.push_back(ret_op.getType());
    }
    auto newType =