LLVM_DEBUG(llvm::dbgs()
               << "Expected a uniform quantized type. Got: " << type << ".\n");
    return false;
  }

  if (!IsStorageTypeI8(quantized_per_axis_type)) {
    LLVM_DEBUG(llvm::dbgs() << "Expected an i8 storage type. Got: "
                            << quantized_per_axis_type << ".\n");
    return false;
  }

  if (!IsExpressedTypeF32(quantized_per_axis_type)) {

LogicalResult MatchZeroPointsOperand(Value zero_points) {
  if (!zero_points) {
    LLVM_DEBUG(llvm::dbgs() << "Zero point value is empty.\n");
    return failure();
  }

  auto zero_points_type =
      mlir::dyn_cast_or_null<TensorType>(zero_points.getType());
  if (!zero_points_type) {
    LLVM_DEBUG(llvm::dbgs() << "Zero point value should be a tensor type. Got: "

  if (kernel_input_feature_dim != 2) {
    LLVM_DEBUG(llvm::dbgs() << "Expected kernel input feature == 2. Got: "
                            << kernel_input_feature_dim << ".\n");
    return failure();
  }

  const int64_t kernel_output_feature_dim =
      dimension_numbers.getKernelOutputFeatureDimension();
  if (kernel_output_feature_dim != 3) {
    LLVM_DEBUG(llvm::dbgs() << "Expected kernel output feature == 3. Got: "

          use->set(map_entry.first->getSecond().getResult());
          LLVM_DEBUG(llvm::dbgs() << "Re-use sunk constant " << use->get()
                                  << "\n     in " << use->get() << "\n");
          if (constant.use_empty()) const_op.erase();
          return;
        }
        if (constant.hasOneUse()) {
          LLVM_DEBUG(llvm::dbgs() << "Moved constant " << constant << "\n");

    } else if (auto identity = dyn_cast<IdentityOp>(op)) {
      LLVM_DEBUG(dump("Visiting ", identity));
      // Try to construct IdentityOp's attribute from recorded assignment.
      if (!GetDeviceAttr(op).empty()) return WalkResult::advance();
      for (auto output : filter_resources(op->getResults())) {
        LLVM_DEBUG(llvm::dbgs() << "  Processing output #"

};
}  // end anonymous namespace

void FunctionalToExecutorDialectConversion::runOnOperation() {
  auto func = getOperation();
  if (func.isExternal()) return;
  if (!llvm::hasSingleElement(func)) {
    LLVM_DEBUG(llvm::dbgs() << "Expect single block function, skip conversion "
                               "to tf_executor dialect\n");
    return;
  }
  auto loc = func.getLoc();
  mlir::Block& body = func.front();

#include "mlir/Pass/PassOptions.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/passes.h"

// Required when using LLVM_DEBUG macro.
#define DEBUG_TYPE "mark-functions-noinline"

namespace mlir {
namespace quant {
namespace {

// Name of the boolean attribute indicating whether the function can be
// inlined or not.

        if (!result_from_use.hasOneUse()) return nullptr;

        device_return = result_from_use.use_begin()->getOwner();
        if (!device_return) return nullptr;
      }
    } else {
      LLVM_DEBUG(llvm::dbgs()
                 << "No supported special parent found, using "
                    "tf_device.cluster_func outputs directly to search for "
                    "consuming AssignVariableOp.\n");
    }
  }

    addConversion([](Type type) {
      if (type.getDialect().getNamespace() ==
          vhlo::VhloDialect::getDialectNamespace()) {
        return type;
      }
      LLVM_DEBUG(llvm::dbgs() << "Invalid type: " << type << '\n');
      return Type();
    });
    addConversion([](stablehlo::TokenType token) {
      return vhlo::TokenV1Type::get(token.getContext());
    });

#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

// Required to use LLVM_DEBUG macro.
#define DEBUG_TYPE "quant-duplicate-shape-determining-constants"

namespace mlir {
namespace quant {
namespace {

// This pass duplicates constants that affect or determine the shape of a tensor