return !device_attr || device_attr.getValue().empty();
}

llvm::StringMap<SmallVector<Cluster>> GetClusters(ModuleOp module) {
  TF::SideEffectAnalysis side_effect_analysis(module);
  auto main_func = module.lookupSymbol<func::FuncOp>("main");
  const TF::SideEffectAnalysis::Info& info =
      side_effect_analysis.GetAnalysisForFunc(main_func);
  llvm::StringMap<SmallVector<Cluster>> clusters = BuildAllClusters(

    std::vector<std::pair<Operation*, Operation*>> side_effect_data;
    const detail::SideEffectAnalysisInfo* info = nullptr;
    auto extra_dependencies =
        [&](Operation* op,
            bool incoming) -> llvm::SmallVector<Operation*, 4> const& {
      return incoming ? info->DirectControlPredecessors(op)
                      : info->DirectControlSuccessors(op);
    };
    // Some tests have recursive calls and other shenanigans, so allow

#ifndef TENSORFLOW_COMPILER_MLIR_TENSORFLOW_UTILS_ATTRIBUTE_UTILS_H_
#define TENSORFLOW_COMPILER_MLIR_TENSORFLOW_UTILS_ATTRIBUTE_UTILS_H_

#include <string>
#include <utility>

#include "llvm/ADT/SmallVector.h"
#include "mlir/IR/Attributes.h"  // from @llvm-project
#include "mlir/IR/Operation.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/tf2xla/tf2xla_defs.h"

    }
    if (isa<mlir::stablehlo::BitcastConvertOp>(op)) {
      // Skip `BitcastConvertOp`, which is handled by the other pattern.
      return failure();
    }

    // Update the results.
    SmallVector<Type, 4> new_results;
    if (failed(getTypeConverter()->convertTypes(op->getResultTypes(),
                                                new_results)))
      return failure();

          return WalkResult::interrupt();
        }).wasInterrupted()) {
    fn.emitOpError("Can't have control ops in this pass.");
    signalPassFailure();
  }

  llvm::SmallVector<Operation *, 4> ops_with_side_effects;

  // We're iterating over all operations at the top block level, excluding
  // the return operation (which otherwise would be recognized as being

  auto attrs = attr_.getAttrs();
  TfLitePoolParams pool_params;

  llvm::SmallVector<int32_t, 2> pool_size;
  if (failed(GetIntegerArraySafe(&func_, attrs, "pool_size", &pool_size, 2))) {
    return failure();
  }
  pool_params.filter_height = pool_size[0];
  pool_params.filter_width = pool_size[1];

  // Retrieve strides.
  llvm::SmallVector<int32_t, 2> strides;

// Converts `called_func` attributes in custom call ops back to `called_index`.
FailureOr<ArrayAttr> DesymbolizeCustomCallCalledIndex(ModuleOp module) {
  Builder builder(module.getContext());

  SmallVector<Attribute> function_list;
  llvm::DenseMap<SymbolRefAttr, int> called_indexes;

  WalkResult result = module.walk([&](stablehlo::CustomCallOp op) {
    if (!IsTfFuncCustomCall(op)) {
      return WalkResult::advance();

  if (!destination_block->empty())
    rewriter.eraseOp(destination_block->getTerminator());

  destination_block->addArguments(
      block_arguments_type,
      SmallVector<Location>(block_arguments_type.size(),
                            source_block->getParent()->getLoc()));
  rewriter.mergeBlocks(source_block, destination_block,
                       destination_block->getArguments());
}

// `get_target` that takes an op and returns the target name. `is_ignored_op` is
// a hook to ignore certain ops that are not included in any clusters.
llvm::StringMap<SmallVector<Cluster>> BuildAllClusters(
    Block& block, const TF::SideEffectAnalysis::Info& side_effect_analysis,
    std::function<std::string(Operation*)> get_target,
    std::function<bool(Operation*)> is_ignored_op);

                      func::FuncDialect>();
  EmptyPatternRewriter pattern_rewriter(builder);
  Value value = CreateConstValue<float>(builder, module->getLoc(), {1024, 2},
                                        SmallVector<float>(2048, 0));

  QuantizationComponentSpec quant_spec;
  quant_spec.set_quantization_component(
      QuantizationComponentSpec::COMPONENT_WEIGHT);