auto reshape_op = FindUserOfType<ReshapeOp>(get_dimension_size_op);
  if (reshape_op == nullptr) return nullptr;

  auto concatenate_op = FindUserOfType<ConcatenateOp>(reshape_op);
  if (concatenate_op == nullptr) return nullptr;

  auto dynamic_broadcast_in_dim_op =
      FindUserOfType<DynamicBroadcastInDimOp>(concatenate_op);
  if (dynamic_broadcast_in_dim_op == nullptr) return nullptr;

    if (is_dynamic_broadcast) {
      auto conv_uses = (*conv_op.getODSResults(0).begin()).getUses();
      if (std::distance(conv_uses.begin(), conv_uses.end()) != 2 ||
          quant::FindUserOfType<shape::ShapeOfOp>(conv_op) == nullptr ||
          quant::FindUserOfType<mhlo::MulOp>(conv_op) == nullptr) {
        return rewriter.notifyMatchFailure(mul_op, [&](::mlir::Diagnostic
                                                           &diag) {

  ASSERT_THAT(dot_general_op, NotNull());

  EXPECT_THAT(FindUserOfType<AddOp>(dot_general_op), NotNull());
  EXPECT_THAT(FindUserOfType<SubtractOp>(dot_general_op), NotNull());
  EXPECT_THAT(FindUserOfType<>(dot_general_op), NotNull());
  EXPECT_THAT(FindUserOfType<ConvolutionOp>(dot_general_op), IsNull());
}

TEST_F(AttrsAndConstraintsTest, FindOperandOfDifferentTypes) {

  Operation* uniform_quantize_op;
  if (!has_i32_output) return op->getResult(0).getType();
  if (fuse_bias_constant) {
    Operation* add_op = FindUserOfType<stablehlo::AddOp>(op);
    uniform_quantize_op = FindUserOfType<TFL::QuantizeOp>(add_op);
  } else {
    uniform_quantize_op = FindUserOfType<TFL::QuantizeOp>(op);
  }
  // StableHLO Quantizer outputs an i32 type. Rewrite to i8 type result
  // to meet TFLite op requirement.

}

// Returns the first user of the given operation, optionally of the given
// type if provided. If there is no user or user of type, return nullptr.
template <typename T = Operation*>
Operation* FindUserOfType(Operation* op) {
  for (Operation* user : op->getUsers()) {
    if (isa<T>(user)) {
      return user;
    }
  }
  return nullptr;
}