cast<stablehlo::SubtractOp>(op.getOperand(0).getDefiningOp());
    auto input1_i8_to_i32_convert_op = cast<stablehlo::ConvertOp>(
        input1_zero_point_subtract_op.getOperand(0).getDefiningOp());
    auto input1_uniform_quantize_call_op = cast<func::CallOp>(
        input1_i8_to_i32_convert_op.getOperand().getDefiningOp());
    auto input1_uniform_quantize_call_pattern =

          if (mlir::isa<BlockArgument>(operand)) continue;

          Operation* predecessor = operand.getDefiningOp();
          if (!operations->contains(predecessor) &&
              !ops_to_avoid.contains(predecessor)) {
            new_ops.insert(operand.getDefiningOp());
            operations->insert(operand.getDefiningOp());
          }
        }
      }
      if (successors) {

        for (Value v : user->getOperands()) {
          if (tensorflow::TypeValidForXLA(v.getType()) &&
              v.getDefiningOp() == op &&
              !llvm::isa<mlir::tf_device::ReturnOp>(user))
            external_outputs.insert(v);
          if (v.getDefiningOp() == op &&
              llvm::isa<mlir::tf_device::ReturnOp>(user))
            tmp_host_outputs.push_back(v);
        }
      }
    }

  "TFL::IsLastDimEqualToNumElements($0.getType(), $1.getType())">>;

def IsDefinedByFullyConnectedOp : Constraint<CPred<
  "$0.getDefiningOp<TFL::FullyConnectedOp>() != nullptr">>;

def IsDefinedByConv2DOp : Constraint<CPred<
  "$0.getDefiningOp<TFL::Conv2DOp>() != nullptr">>;

// Returns true if the supplied value-
// 1) Has only one use or

  auto map_fn = [](Value value) -> int {
    Value parent = value;
    while (true) {
      if (auto identity = parent.getDefiningOp<TF::IdentityOp>()) {
        parent = identity.getInput();
      } else if (auto set_item =
                     parent.getDefiningOp<TF::TensorListSetItemOp>()) {
        parent = set_item.getInputHandle();
      } else {
        break;
      }
    }

    // Check if the only the weight index has QuantizeCastOp.
    auto cur_op = dyn_cast_or_null<quantfork::QuantizeCastOp>(
        call_op.getArgs()[cur_idx].getDefiningOp());
    if (!cur_op && spec->quantizable_operands.contains(cur_idx)) {
      return false;
    } else if (cur_op) {
      // Check if the QuantizeCastOp has element type of quantized type.

      Operation::operand_range &input, IntegerAttr &num_bits,
      BoolAttr &narrow_range,
      ::llvm::SmallVector<Operation *, 4> &target_ops) const {
    auto *defining_op = (*casted_op.getODSOperands(0).begin()).getDefiningOp();
    if (!(defining_op)) {
      return rewriter.notifyMatchFailure(casted_op, [&](Diagnostic &diag) {
        diag << "There's no operation that defines operand 0 of casted_op";
      });
    }