auto *value_op = assign_variable_op.getValue().getDefiningOp();
      auto dq_op = dyn_cast_or_null<DequantizeOp>(value_op);
      if (dq_op) {
        Type output_type = dq_op.getInput().getType();
        auto qtype = quant::QuantizedType::getQuantizedElementType(output_type);
        if (qtype == quant::QuantizedType::getQuantizedElementType(ref_qtype)) {
          // Same quantization parameters, remove it.

// to the `output_buffer`. Both `model_buffer` and `output_buffer` should be a
// valid FlatBuffer format for Model supported by TFLite.
//
// The `input_type`, `output_type` and `inference_type` can be float32 / qint8 /
// int8 / int16.
//
// Returns a partially quantized model if `fully_quantize` is false. Returns a
// non-OK status if the quantization fails.
//

    @Override
    @OutputFile
    RegularFileProperty getOutputLocation();

    /**
     * Always returns {@link Report.OutputType#FILE}
     *
     * @return {@link Report.OutputType#FILE}
     */
    @Override
    OutputType getOutputType();

      flow_type.getRank() != 4) {
    return func_.emitWarning() << "Flow should be a 4D float tensor";
  }

  auto output_type = mlir::dyn_cast_or_null<RankedTensorType>(
      func_.getFunctionType().getResult(0));
  if (!output_type || !output_type.getElementType().isF32() ||
      output_type.getRank() != 4) {
    return func_.emitWarning() << "Output should be a 4D float tensor";
  }

  return success();
}

               << ", output_inference_type: "
               << tflite::EnumNameTensorType(output_type) << "\n";
  mlir::Builder mlir_builder(&context);
  mlir::Type input_mlir_type =
      tflite::ConvertElementType(input_type, mlir_builder);
  mlir::Type output_mlir_type =
      tflite::ConvertElementType(output_type, mlir_builder);

  if (fully_quantize) {

    File getEntryPoint();

    @OutputDirectory
    @Override
    DirectoryProperty getOutputLocation();

    /**
     * Always returns {@link Report.OutputType#DIRECTORY}
     *
     * @return {@link Report.OutputType#DIRECTORY}
     */
    @Override
    OutputType getOutputType();

        final Property<Boolean> required = TestUtil.objectFactory().property(Boolean).value(false)

        TestReport(String name, Describable displayName, OutputType outputType) {
            super(name, displayName, outputType)
        }

        @Override
        FileSystemLocationProperty<? extends FileSystemLocation> getOutputLocation() {
            return null
        }
    }

                @TaskAction
                def doStuff() {
                    reports.enabled.each {
                         if (it.outputType == Report.OutputType.FILE) {
                             assert it.outputLocation.asFile.get().parentFile.exists() && it.outputLocation.asFile.get().parentFile.directory

    if (!input_dequant) return failure();

    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());

    ArrayRef<int64_t> reshape_shape = reshape_type.getShape();

    auto input_type = mlir::cast<ShapedType>(op.getInput().getType());
    auto output_type = mlir::cast<ShapedType>(op.getOutput().getType());

    if (!input_type.hasRank() || !output_type.hasRank()) return failure();

    // The pattern attempts to reduce the rank of the input to BroadcastTo.
    // Thus, we fail to match if the consuming reshape rank is larger.