// For ops that require same operand and result types, use explicit
    // requantize op rather than using `entry_func_op`'s result as op result.
    auto spec = GetStableHloQuantConstraints(singular_op);
    const bool has_same_operand_and_result_type =
        spec->has_same_operand_and_result_type_requirement;
    if (has_same_operand_and_result_type) {

      if (candidate_op->hasTrait<OpTrait::IsTerminator>()) {
        return failure();
      }

      if (!IsOpQuantizableStableHlo(candidate_op)) {
        return failure();
      }

      if (GetStableHloQuantConstraints(candidate_op)
              ->has_same_scale_requirement &&
          !IsConnectedWithQuantizedCompsiteFunction(candidate_op)) {
        return failure();
      }

  ASSERT_TRUE(module_op);

  func::FuncOp main_fn = FindMainFuncOp(*module_op);
  ASSERT_THAT(main_fn, NotNull());

  Operation* gather_op = FindOperationOfType<GatherOp>(main_fn);
  const auto spec = GetStableHloQuantConstraints(gather_op);

  EXPECT_THAT(spec, NotNull());
  EXPECT_THAT(spec->has_same_operand_and_result_type_requirement, IsTrue());
}

}  // namespace