bool use_buffer_offset;
bool emit_stablehlo_ops;
bool disable_vhlo_to_stablehlo;

// NOLINTNEXTLINE
static opt<bool, true> emit_builtin_tflite_ops_flag(
    "emit-builtin-tflite-ops",
    llvm::cl::desc(
        "Emit TFLite built in operations in the generated TFLite model"),
    llvm::cl::location(emit_builtin_tflite_ops), llvm::cl::init(true));

// NOLINTNEXTLINE
static opt<bool, true> emit_select_tf_ops_flag(

        }
      }
    }

    os << "  tflite::" << tflite_option_name << "Builder b(*fbb);\n";
    for (const auto &option : options)
      os << formatv("  b.add_{0}(std::move({0}));\n", option);
    os << "  return b.Finish();\n}\n";
  }
}

// For each TFLite op, emits a builder function that packs the TFLite op into
// the corresponding FlatBuffer object.
//

              [&]() {});
        });
  }
};
}  // namespace

tflite::metrics::ConverterErrorData NewConverterErrorData(
    const std ::string& pass_name, const std::string& error_message,
    tflite::metrics::ConverterErrorData::ErrorCode error_code,
    const std::string& op_name, const Location& location) {
  using tflite::metrics::ConverterErrorData;
  ConverterErrorData error;
  if (!pass_name.empty()) {

#include <string>
#include <vector>

#include "absl/status/status.h"
#include "llvm/Support/SourceMgr.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/tac_importer_exporter.h"

namespace mlir {
namespace TFL {
namespace tac {
// TAC Importer for TFLite.
// This import to MLIR from tflite file or MLIR
class TfLiteImporter : public mlir::TFL::tac::TacImporter {
 public:
  // Options for configuring the importer.

struct ConverterErrorDataComparison {
  std::size_t operator()(
      const tflite::metrics::ConverterErrorData& a,
      const tflite::metrics::ConverterErrorData& b) const noexcept {
    return ConverterErrorDataHash()(a) == ConverterErrorDataHash()(b);
  }
};

// Helper function to create a new ConverterErrorData.
tflite::metrics::ConverterErrorData NewConverterErrorData(

using mlir::func::FuncOp;
using tflite::OperatorT;
using tflite::TensorT;

namespace errors = tensorflow::errors;
namespace tfl = mlir::TFL;

namespace {

constexpr char kScatterRegionFuncName[] = "update_computation_func_name";

using ::mlir::tf_saved_model::kTfSavedModelExportedNamesAttr;
using ::mlir::tf_saved_model::kTfSavedModelIndexPathAttr;
using ::tflite::IsValidBufferOffset;

// RUN: not flatbuffer_translate -mlir-to-tflite-flatbuffer -emit-builtin-tflite-ops=false %s 2>&1 | FileCheck %s

// CHECK: 'tfl.add' op is a TFLite builtin op but builtin emission is not enabled

func.func @main(tensor<3x2xi32>) -> tensor<3x2xi32> {
^bb0(%arg0: tensor<3x2xi32>):
  %0 = "arith.constant"() {name = "Const2", value = dense<10> : tensor<i32>} : () -> tensor<i32>

#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/experimental/tac/common/targets.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/hardwares/target_hardware.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/runtime_metadata_generated.h"
#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"
#include "tensorflow/compiler/mlir/lite/quantization/ir/QuantOps.h"

"""Target aware conversion for TFLite model."""

from tensorflow.compiler.mlir.lite.experimental.tac.py_wrapper import _pywrap_tac_wrapper


def run_tac(model_path, targets, output_path):
  """Run target aware conversion for the given tflite model file.

  Args:
    model_path: Path to the tflite model file.
    targets: A list of string of the desired targets. E.g., ['GPU', 'CPU'].

  bool outline_tf_while = false;
  // Whether to do shape inference.
  bool shape_inference = true;
  // Whether to do TFLite runtime verification.
  bool runtime_verification = true;
  // Whether to enable TFLite variables or not, this will allow
  // mutable variables and produce ReadVariable/AssignVariable ops in TFLite.
  bool enable_tflite_variables = false;
  // Whether to disable the variable freezing pass or not.