TF_DataType output_type, TF_Status* status) {
  size_t input_type_size = TF_DataTypeSize(input_type);
  size_t output_type_size = TF_DataTypeSize(output_type);

  if (input_type_size == 0 || output_type_size == 0) {
    std::ostringstream err;
    err << "Cannot bitcast type " << input_type << " to " << output_type
        << " because one of the type sizes is zero";

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ModifyIONodesPass)

  explicit ModifyIONodesPass() {}
  explicit ModifyIONodesPass(mlir::Type input_type, mlir::Type output_type) {
    this->input_type = input_type;
    this->output_type = output_type;
  }

  void runOnOperation() override;

 private:
  // Assign the io types from the command line flag. This is only required for
  // tests.

    public void setOutputType(OutputType outputType) {
        this.outputType = outputType;
    }

    @OptionValues("output-type")
    public List<OutputType> getAvailableOutputTypes() {
        return new ArrayList<OutputType>(Arrays.asList(OutputType.values()));
    }

    @Input
    public OutputType getOutputType() {
        return outputType;
    }

    @TaskAction

    public void setOutputType(OutputType outputType) {
        this.outputType = outputType;
    }

    @OptionValues("output-type")
    public List<OutputType> getAvailableOutputTypes() {
        return new ArrayList<OutputType>(Arrays.asList(OutputType.values()));
    }

    @Input
    public OutputType getOutputType() {
        return outputType;
    }

    @TaskAction

    DIRECTORY(TreeType.DIRECTORY),
    FILES(TreeType.FILE),
    DIRECTORIES(TreeType.DIRECTORY);

    private final TreeType outputType;

    OutputFilePropertyType(TreeType outputType) {
        this.outputType = outputType;
    }

    public TreeType getOutputType() {
        return outputType;
    }

    auto input_type =
        mlir::dyn_cast<RankedTensorType>(dequantize_op.getOutput().getType());
    auto output_type = mlir::dyn_cast<RankedTensorType>(
        passthrough_op->getResult(0).getType());
    if (!input_type || !output_type ||
        get_num_elements(input_type) <= get_num_elements(output_type)) {
      return failure();
    }
    Type input_element_type = getElementTypeOrSelf(dequantize_op.getInput());

    private final TreeType outputType;

    public DefaultCacheableOutputFilePropertySpec(
        String propertyName,
        @Nullable String propertySuffix,
        FileCollectionInternal outputFiles,
        TreeType outputType
    ) {
        super(propertyName, OutputNormalizer.INSTANCE, outputFiles);
        this.propertySuffix = propertySuffix;
        this.outputType = outputType;
    }

    @Override

      func.return %act : tensor<*x${output_type}>
    }

    parameters[
      {"quantized_ops": ["${main_op}"], "act_func": "internal_requantize_no_activation_fn", "output_type": "!tf_type.qint8"},
      {"quantized_ops": ["${main_op}", "Relu"], "act_func": "internal_requantize_and_relu_fn", "output_type": "!tf_type.qint8"},

    private final String name;
    private final Describable displayName;
    private final OutputType outputType;

    public SimpleReport(String name, Describable displayName, OutputType outputType) {
        this.name = name;
        this.displayName = displayName;
        this.outputType = outputType;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override

LogicalResult ConstantTensorOp::verify() {
  ConstantTensorOp op = *this;
  auto input_type = op.getArg().getType();
  auto output_type = op.getOut().getType();

  if (auto output_tensor_type = output_type.dyn_cast<TFRTensorType>()) {
    return success();
  }

  auto output_tensor_type = output_type.dyn_cast<RankedTensorType>();
  if (!output_tensor_type || !output_tensor_type.hasStaticShape()) {