namespace mlir::quant {
namespace {

void PackOperandTestHelper(
    const llvm::SmallVector<int64_t>& unpacked_shape,
    const llvm::SmallVector<int8_t>& unpacked_values, int pack_dim,
    const llvm::SmallVector<int64_t>& expected_packed_shape,
    const llvm::SmallVector<int8_t>& expected_packed_values) {
  MLIRContext context;
  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));

// of the index path attribute.
SmallVector<NamedAttribute> ReplaceBoundInputAttrWithIndexPathAttr(
    const ArrayRef<NamedAttribute> arg_attrs, const StringRef index_path,
    Builder& builder) {
  // Keep all other attributes except the tf_saved_model.bound_input attribute,
  // as we are replacing it with tf_saved_model.index_path.
  SmallVector<NamedAttribute> new_arg_attrs;
  for (auto arg_attr : arg_attrs) {

  // time-majored. shrink_axis_mask: should be 0b010 = 2 or 0b001 = 1 if it's
  // time-majored.
  SmallVector<int64_t, 2> last_output_shape({batch, n_output});

  SmallVector<int32_t, 3> end({0, 0, 0});
  SmallVector<int32_t, 3> strides({1, 1, 1});
  SmallVector<int32_t, 3> begin;

  int64_t new_axis_mask = 0;
  int64_t ellipsis_mask = 0;
  int64_t begin_mask;
  int64_t end_mask;

            .getValue(),
        ftype);

    func->setAttrs(graph_func->getAttrs());

    llvm::SmallVector<Type> arg_types;
    llvm::SmallVector<Type> res_types;
    llvm::SmallVector<DictionaryAttr> arg_attrs;
    llvm::SmallVector<DictionaryAttr> res_attrs;
    if (failed(FilterTfgSpecificArgResultAttributes(
            getContext(), ftype.getInputs(), graph_func.getAllArgAttrs(),

  const UniformQuantizedPerAxisType quantized_type =
      CreateI8F32UniformQuantizedPerAxisType(
          UnknownLoc::get(&ctx_), ctx_,
          /*scales=*/SmallVector<double, 2>{1.0, 1.0},
          /*zero_points=*/SmallVector<int64_t, 2>{0, 0},
          /*quantization_dimension=*/0);

  // Storage type of `i8` is currently verifiable as `unsigned` in `Types.cpp`.

    // and input devices, variables used by this function.
    llvm::SmallVector<llvm::StringRef, 4> input_names;
    llvm::SmallVector<
        std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>, 4>
        input_specs;
    llvm::SmallVector<llvm::StringRef, 4> input_devices;
    llvm::SmallVector<mlir::Operation*, 4> bound_inputs;
    for (unsigned i = 0, e = func.getNumArguments(); i != e; ++i) {

          device_cluster.getLoc(), num_regions, llvm::ArrayRef<Type>{});
  SmallVector<Operation*, 4> core_to_host_insertion_point;
  SmallVector<mlir::tf_device::LaunchOp, 4> core_to_tmp_launch;
  SmallVector<Operation*, 4> compilation_key_ops;
  SmallVector<Value, 4> core_to_compilation_key;
  SmallVector<Operation*, 4> core_to_device_ordinal_op;
  SmallVector<Value, 4> core_to_device_ordinal;

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir {
namespace TF {

SmallVector<int64_t, 4> ReversePermutation(ArrayRef<int64_t> permutation) {
  SmallVector<int64_t, 4> reverse(permutation.size());
  for (size_t i = 0; i < permutation.size(); ++i) {
    reverse[permutation[i]] = i;
  }
  return reverse;
}

SmallVector<int64_t, 4> GetDataFormatPermutation(StringRef from, StringRef to) {

      for (Operation& op : nested_block->getOperations()) update_from_op(&op);
    });
  }
  return SmallVector<Value>(results.getArrayRef());
}

llvm::SmallVector<Value> AccumulateResultsDefinedWithin(
    const llvm::SetVector<Operation*>& partition_ops) {
  llvm::SmallVector<Value> values_for_results;
  for (Operation* op : partition_ops) {
    if (IsConstantOrNone(op)) {
      continue;
    }

func::FuncOp createLstmCompositeFunc(mlir::Builder* builder, bool ln,
                                     bool cifg) {
  SmallVector<int64_t, 2> input_shape{1, 2};
  SmallVector<int64_t, 2> weight_shape{3, 12};
  SmallVector<int64_t, 1> bias_shape{2};
  SmallVector<int64_t, 2> projection_shape{1, 2};
  SmallVector<int64_t, 1> layer_norm_scale{4};
  SmallVector<int64_t, 2> output_shape{1, 2};
  auto input_type = RankedTensorType::get(input_shape, builder->getF32Type());