%18 = "tf.Round"(%17) : (tensor<f32>) -> tensor<f32>
    %19 = "tf.Cast"(%18) : (tensor<f32>) -> tensor<i32>
    %20 = "tf.AddV2"(%19, %arg10) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    %21 = "tf.Cast"(%20) : (tensor<i32>) -> tensor<i8>
    %22 = "tf.Cast"(%21) {Truncate = false} : (tensor<i8>) -> tensor<i8>
    %23 = "tf.Cast"(%22) {Truncate = false} : (tensor<i8>) -> tensor<i32>

      filter_i8_value_attr = mlir::cast<DenseIntElementsAttr>(
          cast<stablehlo::ConstantOp>(filter_op->getOperand(0).getDefiningOp())
              .getValue());
    }

    // Create Uniform Quantized constant for the filter.
    auto subtract_op =
        cast<stablehlo::SubtractOp>(*op.getResult().user_begin());
    auto other_conv_op = cast<stablehlo::ConvolutionOp>(

  "$0.isa<DenseElementsAttr>() && "
  "$0.cast<DenseElementsAttr>().getNumElements() == 1 && "
  "(($0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isLargest() && "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegative()) || "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegInfinity())">>;

def L2NormValidReduceIndex : Constraint<CPred<
  "L2NormalizeReduceAxis($0, $1.cast<DenseElementsAttr>())">>;

    return errors::InvalidArgument("Cast requires 2 arguments");
  }
  if (grad_inputs.size() != 1) {
    return errors::InvalidArgument("Cast grad requires 1 grad input");
  }

  auto src_type = op.input_type(0);
  auto dst_type = grad_inputs[0].type();
  if (IsFloatingPointDtype(src_type) && IsFloatingPointDtype(dst_type)) {
    grad_outputs->push_back(Cast(scope, grad_inputs[0], src_type));
  } else {

    auto op = cast<ResizeNearestNeighborOp>(src_op);
    auto loc = op.getLoc();
    auto result_ty = mlir::cast<ShapedType>(op.getType());

    auto input = op.getImages();
    auto input_ty = mlir::cast<ShapedType>(input.getType());
    auto input_element_ty = input_ty.getElementType();
    auto out_size = op.getSize();
    auto out_size_ty = mlir::cast<ShapedType>(out_size.getType());

//	                  ::= <substitution>
//
//	<decltype> ::= Dt <expression> E
//	           ::= DT <expression> E
func (st *state) prefix() AST {
	var a AST

	// The last name seen, for a constructor/destructor.
	var last AST

	var module AST

	getLast := func(a AST) AST {
		for {
			if t, ok := a.(*Template); ok {
				a = t.Name
			} else if q, ok := a.(*Qualified); ok {
				a = q.Name

      ShapedType new_output_type = ConvertIntToQint(
          mlir::cast<ShapedType>(output_type), rewriter.getContext());
      if (!new_output_type) {
        dq_op->emitError(
            "Failed to convert the type to the corresponding qtype.");
        return failure();
      }
      output_type = mlir::cast<TensorType>(new_output_type);
    }

            // CHECK: %[[CAST:.+]] = "tf.Cast"(%[[CARG1]])
            // CHECK: "tf.Less"(%[[CARG0]], %[[CAST]])
            // CHECK: "tf.Yield"
            ^bb0(%carg0: tensor<i32>, %carg1: !tf_ref, %carg2: !tf_ref, %carg3: !tf_ref):
               %read0 = "tf.ReadVariableOp"(%carg1) : (!tf_ref) -> tensor<f32>
               %cast = "tf.Cast"(%read0) : (tensor<f32>) -> tensor<i32>

    // * The 'strides' attribute must exist and is of the form [1, X, Y, 1].
    // * The 'dilations' attribute is optional, but it must be of the form
    //   [1, X, Y, 1] if exists.

    TFConvOpType tf_op = cast<TFConvOpType>(op);
    if (!TFTypeIsFloat32Tensor(tf_op.getInput()) &&
        !(allow_bf16_and_f16_type_legalization_ &&
          TFTypeIsBFloat16OrHalfTensor(tf_op.getInput())))
      return failure();

  %4 = "tf.GatherV2"(%cst_1, %arg1, %cst_0) {batch_dims = 0 : i64, device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<3xi32>, tensor<i32>, tensor<i32>) -> tensor<i32>
  %5 = "tf.Cast"(%4) {Truncate = false, device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<i32>) -> tensor<f32>