mlir::tfd::ConvertTftToDhtOp op,
      mlir::PatternRewriter& rewriter) const override {
    // Look through the inputs of the ConvertTftToDhtOp.
    mlir::Value convert_op_input_0 = op.getOperand(0);
    mlir::Value convert_op_input_1 = op.getOperand(1);
    mlir::tfd::MoveDhtToTftOp move_input_op_0 =
        llvm::dyn_cast_or_null<mlir::tfd::MoveDhtToTftOp>(
            convert_op_input_0.getDefiningOp());

  LogicalResult match(mlir::stablehlo::ConvolutionOp op) const override {
    // Handles 2D convolutions only.
    if (!HasRankOf(op.getOperand(0), /*rank=*/4) ||
        !HasRankOf(op.getOperand(1), /*rank=*/4)) {
      return failure();
    }

    if (!IsOpNotQuantized(op)) return failure();

    const ConvDimensionNumbersAttr dimension_nums = op.getDimensionNumbers();

    Operation* pi = operand.getDefiningOp();
    for (unsigned core_id = 0; core_id < num_cores_per_replica; ++core_id) {
      const auto pi_operand =
          packed_input ? pi->getOperand(0) : pi->getOperand(core_id);
      operands_per_replica_per_core[core_id].push_back(pi_operand);
    }
  }

  // Create new `tf.TPUReplicatedInput` ops feeding into one
  // `tf.TPUPartitionedInputV2` op.

      if (is_op_a && *result_constraint == ValueConstraint::kShape)
        operands.Insert(op->getOperand(0), ValueConstraint::kRank);

      // `test.OpB` converts value constraint to shape constraint.
      if (*result_constraint == ValueConstraint::kValue)
        operands.Insert(op->getOperand(0), ValueConstraint::kShape);
    }

    return success();
  }
};

    if (!erf_user_user_input) return failure();

    // Check `mul 0.5` and `mul 1/sqrt(2)` refer to the same input.
    if (erf_user_user_input->getOperand(0) != erf_input->getOperand(0)) {
      return failure();
    }

    // Check the structural matches have the correct op type and values.
    auto rhs_mul = llvm::dyn_cast_or_null<stablehlo::MulOp>(erf_input);

// variable is not saved, returns an empty string.
absl::StatusOr<std::string> AddTensorToBundleWriter(
    mlir::TF::AssignVariableOp assign_var_op, BundleWriter& bundle_writer) {
  auto resource_operand = assign_var_op.getOperand(0);
  auto var_handle_op =
      llvm::dyn_cast<mlir::TF::VarHandleOp>(resource_operand.getDefiningOp());
  if (!var_handle_op) {
    assign_var_op->emitRemark(

    Value pad_input = pad_op.getOperand();
    RankedTensorType pad_type = pad_op.getType().cast<RankedTensorType>();

    auto transpose_op = pad_input.getDefiningOp<stablehlo::TransposeOp>();
    if (!transpose_op || !transpose_op->hasOneUse()) return failure();
    Value transpose_input = transpose_op.getOperand();

    ArrayRef<int64_t> transpose_perm = transpose_op.getPermutation();

  using OpRewritePattern<TF::AssignVariableOp>::OpRewritePattern;

  LogicalResult match(TF::AssignVariableOp assign_op) const override {
    Value resource_operand = assign_op.getOperand(0);
    Value assigned_value_operand = assign_op.getOperand(1);

    if (isa<TF::VarHandleOp>(resource_operand.getDefiningOp()) &&
        isa<TF::ConstOp>(assigned_value_operand.getDefiningOp())) {
      return success();
    } else {

  Operation* xla_call_module_op =
      FindOperationOfType<TF::XlaCallModuleOp>(main_fn);
  Operation* filter_dcast_op =
      xla_call_module_op->getOperand(1).getDefiningOp();
  Operation* filter_qcast_op = filter_dcast_op->getOperand(0).getDefiningOp();
  ASSERT_NE(filter_qcast_op, nullptr);
  EXPECT_TRUE(isa<quantfork::QuantizeCastOp>(filter_qcast_op));

                             Operation* user_op, int user_idx,
                             Type new_user_op_type) const {
    auto op_before_dequantize = original_dequantize_op.getOperand(0);

    // Create a new dequantize op that is propagated.
    rewriter.setInsertionPointAfter(user_op);
    TF::PartitionedCallOp new_dequantize_op =