llvm::SetVector<Operation*> ops_depend_on_cluster;
  for (Operation& op : *c.ops.front()->getBlock()) {
    if (op.isBeforeInBlock(c.ops.front()) || c.ops.contains(&op)) {
      continue;
    }
    // Gets the live in values of the `op`
    llvm::SetVector<Value> live_ins(op.operand_begin(), op.operand_end());
    getUsedValuesDefinedAbove(op.getRegions(), live_ins);

    if (isa<TF::TPUCopyWithDynamicShapeOp>(op)) {
      if (failed(CheckOpIsValid(op))) return WalkResult::interrupt();
      if (CanMove(op)) {
        tpu_copy_with_dynamic_shape_ops.push_back(op);
      }
    }
    return WalkResult::advance();
  });
  if (walk_result.wasInterrupted()) return signalPassFailure();

  for (Operation* op : tpu_copy_with_dynamic_shape_ops) {

    if (!main) {
      op->emitError() << "MLIR Opaque Op expects a main() entry point\n";
      return;
    }
    if (main.getNumArguments() != op->getNumOperands()) {
      op->emitError() << "mismatch between MLIR Opaque Op number of operands ("
                      << op->getNumOperands()
                      << ") and main() entry point in the module ("

// during import.
template <typename Op>
struct DropAttributes : public OpRewritePattern<Op> {
  using OpRewritePattern<Op>::OpRewritePattern;

  // Drop the "output_shapes" attribute.
  LogicalResult matchAndRewrite(Op op,
                                PatternRewriter &rewriter) const override {
    bool found = !!op->removeAttr("output_shapes");
    return success(found);
  }
};

  llvm::DenseSet<Block*> blocks;
  Operation* op = bottom;
  while (op && op != top) {
    blocks.insert(op->getBlock());
    op = op->getParentOp();
  }
  return blocks;
}

// For a given value defined somewhere underneath `target_blocks`, get the
// result that's emitted through the op(s) that wrap it, in one of the
// `target_blocks`.

}

bool ShouldMoveOutOfRegion(
    Operation *op, Region *region,
    const llvm::DenseSet<ResourceHandle> &read_only_vars) {
  return ResourceOpCanBeHoisted(op, region, read_only_vars) ||
         (isMemoryEffectFree(op) && isSpeculatable(op));
}

bool OnlyHasReadEffect(Operation *op) {
  auto interface = llvm::dyn_cast<MemoryEffectOpInterface>(op);
  if (!interface) return false;

      return failure();
    }
    element_type = getElementTypeOrSelf(op->getOperand(1).getType());
  }
  if (attr == "output_quantization") {
    if (op->getNumResults() < 1) {
      return failure();
    }
    element_type = getElementTypeOrSelf(op->getOpResult(0).getType());
  }
  if (element_type) {
    is_8_bit = mlir::isa<TF::Qint8Type>(element_type);
    return success();
  }

};

void MarkCompilationOps(Operation* func) {
  func->walk([&](Operation* op) {
    if (llvm::isa<TF::_TPUCompileMlirOp>(op)) {
      op->setAttr("_is_compilation", UnitAttr::get(func->getContext()));
      op = op->getParentOp();
      while (op && op != func) {
        op->setAttr("_wraps_compilation", UnitAttr::get(func->getContext()));
        op = op->getParentOp();
      }
    }
  });
}

  ASSERT_TRUE(succeeded(res));
  ASSERT_EQ(2147483647, op.getLhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getLhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getRhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getRhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getOutputQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getOutputQuantizationMinValAttr().getInt());

      return states_[operand_states_[{op, index}]];
    }

    // Returns the state of the index-th result of the op.
    QuantState &GetResultQuantState(Operation *op, int index) {
      return states_[result_states_[{op, index}]];
    }

    // Returns the state of the index-th operand of the op.
    RequantizeState &GetOperandRequantizeState(Operation *op, int index) {