%0 = "quantfork.qcast"(%cst_1) : (tensor<2x3x3x2xf32>) -> tensor<2x3x3x2x!quant.uniform<i8<-127:127>:f32:3, {0.003937007874015748,0.003937007874015748}>>
  %1 = "quantfork.dcast"(%0) : (tensor<2x3x3x2x!quant.uniform<i8<-127:127>:f32:3, {0.003937007874015748,0.003937007874015748}>>) -> tensor<2x3x3x2xf32>

// TODO(b/204265523): Removes this pass after the exporting MLIR to SavedModel
// path is available.
std::unique_ptr<OperationPass<ModuleOp>> CreateInsertMainFunctionPass();

// Converts FakeQuant ops to quant.qcast and quant.dcast (QDQ) pairs.
std::unique_ptr<OperationPass<func::FuncOp>> CreateConvertFakeQuantToQdqPass();

// Lifts the quantizable spots as composite functions.
std::unique_ptr<OperationPass<ModuleOp>>

        rewriter.replaceOpWithNewOp<mlir::stablehlo::ConstantOp>(
            op, qtype, quantized_attr);
        return success();
      }
    }
    return failure();
  }
};

// Replaces quantfork.dcast with stablehlo.uniform_dequantize.
class ConvertDequantizeCastToUniformDequantizePattern
    : public OpRewritePattern<quantfork::DequantizeCastOp> {
 public:

      ConstantOp new_const = rewriter.create<ConstantOp>(
          op->getLoc(), new_result_type, new_value_attr);
      ConvertOp dcast =
          rewriter.create<ConvertOp>(op->getLoc(), old_result_type, new_const);
      // replace all convert ops with dq op.
      convert_op->replaceAllUsesWith(dcast);
      // Return without scanning for the next ConvertOp as only one ConvertOp is
      // connected to all quantizable ops.

    return false;

  if (mlir::cast<IntegerAttr>(elements.front()).getInt() != 1 ||
      mlir::cast<IntegerAttr>(elements.back()).getInt() != 1)
    return false;

  Builder b(op->getContext());
  *x = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[1]).getInt());
  *y = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[2]).getInt());
  *z = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[3]).getInt());

        then:
        property.get() == cast(["first", "second", "third", "forth", "fifth"])

        when:
        collection.remove("third")

        then:
        property.get() == cast(["first", "second", "forth", "fifth"])
        collection.size() == 4

        when:
        collection.add("third")

        then:
        property.get() == cast(["first", "second", "forth", "fifth", "third"])

    spec->required_same_scale_func = [op](const bool sign,
                                          const int bit_width) {
      return cast<SameScalesOpInterface>(op)
          .RequiredSameOperandsAndResultsScale(sign, bit_width);
    };
    spec->required_same_quantized_axes_func = [op]() {
      return cast<SameScalesOpInterface>(op).RequiredSameQuantizedAxes();
    };
  }
  if (isa<FixedOutputRangeInterface>(op)) {

    if (!mlir::cast<ShapedType>(conv_op.getRhs().getType()).hasStaticShape()) {
      return false;
    }
    if (!mlir::cast<ShapedType>(conv_op.getLhs().getType()).hasStaticShape() &&
        !mlir::cast<ShapedType>(conv_op.getType()).hasStaticShape()) {
      auto dnums = conv_op.getDimensionNumbers();
      auto lhs_type = mlir::cast<ShapedType>(conv_op.getLhs().getType());

package org.gradle.internal

import spock.lang.Specification

import static Cast.cast

class CastTest extends Specification {

    def "casting"() {
        given:
        def arg = "1"

        when:
        cast(Integer, arg)

        then:
        def e = thrown(ClassCastException)
        e.message == "Failed to cast object $arg of type ${arg.class.name} to target type ${Integer.name}"

        when:

    // Check if the same-scale requirement is met.
    auto dq_arg_type = preceding_sc_op.getArg().getType().cast<TensorType>();
    auto qtype = dq_arg_type.getElementType().cast<QuantizedType>();
    auto q_result_type = sc_op.getType().cast<TensorType>();
    auto out_qtype = q_result_type.getElementType().cast<QuantizedType>();
    if (qtype != out_qtype) {
      avg_pool_op.emitError(