if (!IsQI32Type(input_dequant.getType())) return failure();

    auto output_type =
        mlir::dyn_cast_or_null<ShapedType>(dequant_op.getOutput().getType());
    if (!output_type || !output_type.getElementType().isF32()) return failure();

    auto input_type = mlir::dyn_cast<ShapedType>(input_dequant.getType());
    // TODO(renjieliu): support UniformQuantizedPerAxisType.

    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 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) {

  // doesn't require quantization.
  auto tensor_type = mlir::dyn_cast<TensorType>(value.getType());
  if (!tensor_type) {
    // There are none type values.
    return;
  }
  if (!tensor_type.getElementType().isF32()) return;

  // If the result is consumed by a quantize op, it has been quantized.
  if (value.hasOneUse() &&
      llvm::isa<TFL::QuantizeOp>(*value.getUsers().begin()))
    return;