return false;
}

bool IsQuantizedTensorType(Type type) {
  if (!mlir::isa<TensorType>(type)) {
    return false;
  }
  Type element_type = mlir::cast<TensorType>(type).getElementType();
  return mlir::isa<QuantizedType>(element_type);
}

bool IsOpFullyQuantized(Operation* op) {
  return llvm::all_of(op->getOperandTypes(), IsQuantizedTensorType) &&

      const TensorType type, const ArrayRef<int64_t> permutation) const {
    const SmallVector<int64_t> after_shape =
        Permute<int64_t>(type.getShape(), permutation);
    return type.cloneWith(after_shape, type.getElementType());
  }
};

}  // namespace

void NchwConvolutionToNhwcPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();

    // TODO(hinsu): Handle constants that are not scalar booleans.
    auto cond_type = mlir::dyn_cast<RankedTensorType>(cond.getType());
    if (!cond_type || !cond_type.getShape().equals({}) ||
        !cond_type.getElementType().isInteger(/*width=*/1))
      return failure();

    // Identify the branch to inline.
    bool cond_value = (*cond.value_begin<APInt>()).getSExtValue();
    func::FuncOp func = cond_value ? then_func : else_func;

  SmallVector<int64_t, 4> permutedShape = applyPermutation(
      type.getShape(), isInvert ? invertPermutationVector(perm) : perm);
  return RankedTensorType::get(permutedShape, type.getElementType());
}

static RankedTensorType GetInvertPermutedTensorType(RankedTensorType type,
                                                    ArrayRef<int64_t> perm) {

    if (!const_op) return failure();

    // Only support float tensors.
    auto tensor_type = mlir::dyn_cast_or_null<TensorType>(const_op.getType());
    if (!tensor_type || !tensor_type.getElementType().isF32()) {
      return failure();
    }

    return success(
        mlir::isa_and_nonnull<DenseFPElementsAttr>(const_op.getValue()));
  }

  void rewrite(mlir::stablehlo::TransposeOp op,

    auto tensor =
        llvm::dyn_cast<TensorType>(var_handle_op.getResource().getType());
    if (!tensor) return nullptr;
    TF::ResourceType resource =
        llvm::dyn_cast<TF::ResourceType>(tensor.getElementType());
    if (!resource || resource.getSubtypes().size() != 1) return nullptr;
    return resource.getSubtypes().front();
  } else if (auto global_tensor_op =

      auto arg_type = mlir::cast<RankedTensorType>(arg.getType());
      assert(arg_type.getRank() == 0);
      llvm::ArrayRef<TensorType> underlying_type =
          mlir::cast<TF::ResourceType>(arg_type.getElementType()).getSubtypes();

      // If the arg type already matches the global_tensor type, we don't need
      // to do anything.
      if (!underlying_type.empty() &&

  int64_t output_size = InferTensorSize(context, value_type);

  int64_t cost = kLookupTableFindCostScale * output_size;

  if (mlir::isa<mlir::TF::StringType>(key_type.getElementType()))
    cost *= kLookupTableFindStringKeyCostScale;

  return cost;
}

// The cost function for tf.GatherV2.
int64_t InferGatherV2Cost(const CostContext& context, mlir::TF::GatherV2Op op) {

  // require "raising" later.
  for (const Type type : inst->getResultTypes()) {
    if (const TensorType tensor_type = mlir::dyn_cast<TensorType>(type)) {
      if (mlir::isa<VariantType>(tensor_type.getElementType())) {
        return false;
      }
    }
  }

  // Operations that execute function calls shouldn't be constant folded.
  if (llvm::isa<TF::WhileOp, TF::CaseOp, TF::IfOp, CallOpInterface>(inst)) {

      ShapedType value_shaped_type = mlir::dyn_cast_or_null<ShapedType>(
          value_for_deducing_op_type.getType());
      if (value_shaped_type != nullptr) {
        auto operand_or_result = value_shaped_type.getElementType();
        std::string dtype;

        TypeSwitch<Type>(operand_or_result)
            .Case<IntegerType>([&](Type) {
              dtype =