Value ConvertConditionToBoolean(Operation* op, Value cond) {
  if (auto ranked_type = mlir::dyn_cast<RankedTensorType>(cond.getType()))
    if (ranked_type.getRank() == 0 &&
        ranked_type.getElementType().isSignlessInteger(1))
      return cond;

  OpBuilder builder(op);
  Value to_bool = builder.create<TF::ToBoolOp>(op->getLoc(), cond);
  CopyDeviceAndUnderscoredAttributes(op, to_bool.getDefiningOp());

  auto cst_op = llvm::dyn_cast_or_null<stablehlo::ConstantOp>(cst_input);
  if (!cst_op) return false;
  ElementsAttr value = cst_op.getValue();
  if (!value.isSplat()) return false;
  if (!value.getElementType().isF32()) return false;
  return std::abs(value.getSplatValue<float>() - val) < kTolerance;
}

// Determines if the given op is semantically that of the gauss error function.
bool MatchERF(Operation* op) {

  LogicalResult match(Operation* op) const override {
    if (op->getNumResults() != 1) {
      return failure();
    }
    auto type = mlir::cast<TensorType>(op->getResult(0).getType());
    if (!type || !type.getElementType().isF32()) {
      return failure();
    }
    return success(
        op->hasOneUse() &&
        IsWeightQuantizableFunction(*op->getUses().begin(), type.getRank()));
  }

        Permute<int64_t>(result_type.getShape(), kNchwToNhwcPermutation);

    const TensorType new_result_type =
        result_type.cloneWith(new_result_shape, result_type.getElementType());

    // Create a new `stablehlo.reduce_window` with all relevant attributes
    // permutated to match the new operand & result type.
    auto new_reduce_window_op =

                         QuantizationUnits& quantizable_ops) const {
    // Non-float tensors do not need quantization.
    auto type = mlir::dyn_cast<ShapedType>(op.getType());
    if (!type || !type.getElementType().isF32()) return false;

    Value value = op.getResult();

    // Check whether dynamic range quantization can be applied.
    for (auto& use : value.getUses()) {
      Operation* user = use.getOwner();

  llvm::SmallVector<int64_t> shape = {pool.n, h, w, pool.c};

  auto op_type = mlir::cast<RankedTensorType>(op->getResult(0).getType());
  return RankedTensorType::get(shape, op_type.getElementType());
}

StringAttr GetAvgPoolOpPadAttr(Builder& builder, CompositeOp op) {
  const TorchAvgPoolData pool = GetTorchAvgPoolData(op);

  if (pool.ph == 0 && pool.pw == 0) {

    if (cur_rank != 4 || cur_shape[2] == 1) return failure();
    TensorType new_shape = RankedTensorType::get(
        {cur_shape[0], cur_shape[1], 1, cur_shape[2] * cur_shape[3]},
        attr.getElementType());

    // Inserts a reshape op.
    auto shape_spec_type =
        RankedTensorType::get({cur_rank}, rewriter.getIntegerType(64));
    auto new_shape_const_attr =

                   permuted_shape.begin() + input_rank - 2);
    return rewriter.create<TFL::TransposeOp>(
        op->getLoc(),
        RankedTensorType::get(permuted_shape, input_type.getElementType()),
        input, permutation_tensor_op.getResult());
  };

  if (!can_convert_to_fully_connected(op)) {
    return false;
  }

  Value input_lhs = get_real_input_value(op.getX());

        if (auto attr = inst.getAttrOfType<mlir::ElementsAttr>(attr_id)) {
          mlir::Attribute rand_val;
          mlir::Type element_type = attr.getShapedType().getElementType();
          if (mlir::isa<mlir::IntegerType>(element_type)) {
            rand_val = mlir::IntegerAttr::get(element_type, std::rand());
          } else if (element_type.isF16() || element_type.isF32() ||

      elemType.isInteger(64))
    return true;

  // Complex<F<32>> is allowed.
  if (mlir::isa<ComplexType>(elemType) &&
      mlir::cast<ComplexType>(elemType).getElementType().isF32())
    return true;

  // QUINT8 and UI8 are allowed.
  if (mlir::isa<TF::Quint8Type>(elemType) ||
      (elemType.isInteger(8) && mlir::cast<IntegerType>(elemType).isUnsigned()))
    return true;