
from __future__ import annotations
def 				__magic_name__(					UpperCAmelCase__   :					Any  ):
						global graph, reversed_graph, scc, component, visit, stack
						if visit[u]:
												return
						UpperCamelCase_    :  Union[str, Any]				    =    True
						for v in graph[u]:
												dfs(lowercase__  )
						stack.append(lowercase__  )
def 				__magic_name__(					UpperCAmelCase__   :					List[Any]  ):
						global graph, reversed_graph, scc, component, visit, stack
						if visit[u]:
												return
						UpperCamelCase_    :  Dict				    =    True
						component.append(lowercase__  )
						for v in reversed_graph[u]:
												dfsa(lowercase__  )
def 				__magic_name__(					):
						global graph, reversed_graph, scc, component, visit, stack
						for i in range(lowercase__  ):
												dfs(lowercase__  )
						UpperCamelCase_    :  str				    =    [False] * n
						for i in stack[::-1]:
												if visit[i]:
																		continue
												UpperCamelCase_    :  Union[str, Any]				    =    []
												dfsa(lowercase__  )
												scc.append(lowercase__  )
						return scc


if __name__ == "__main__":
	# n - no of nodes, m - no of edges
	__SCREAMING_SNAKE_CASE  =			list(map(int, input().strip().split()))

	__SCREAMING_SNAKE_CASE  =			[[] for _ in range(n)]  # graph
	__SCREAMING_SNAKE_CASE  =			[[] for i in range(n)]  # reversed graph
	# input graph data (edges)
	for _ in range(m):
		__SCREAMING_SNAKE_CASE  =			list(map(int, input().strip().split()))
		graph[u].append(v)
		reversed_graph[v].append(u)

	__SCREAMING_SNAKE_CASE  =			[]
	__SCREAMING_SNAKE_CASE  =			[False] * n
	__SCREAMING_SNAKE_CASE  =			[]
	__SCREAMING_SNAKE_CASE  =			[]
	print(kosaraju())






'''simple docstring'''


from .hash_table import HashTable
from .number_theory.prime_numbers import is_prime, next_prime




class 						__snake_case (						_a  ):




		def __init__(     self				:Optional[Any] ,						*_SCREAMING_SNAKE_CASE				:Union[str, Any] ,						**_SCREAMING_SNAKE_CASE				:List[Any])				-> List[str]:






								'''simple docstring'''






								super().__init__(*_SCREAMING_SNAKE_CASE ,						**_SCREAMING_SNAKE_CASE)




		def   _snake_case  (     self				:Union[str, Any] ,						_SCREAMING_SNAKE_CASE				:Union[str, Any] ,						_SCREAMING_SNAKE_CASE				:List[Any])				-> Optional[int]:






								'''simple docstring'''






								UpperCamelCase_    :  Optional[Any]				    =    (
								    next_prime(value % self.size_table)
								    if not is_prime(value % self.size_table)
								    else value % self.size_table
								)  # gt = bigger than
								return next_prime_gt - (data % next_prime_gt)




		def   _snake_case  (     self				:List[str] ,						_SCREAMING_SNAKE_CASE				:Optional[int] ,						_SCREAMING_SNAKE_CASE				:Any ,						_SCREAMING_SNAKE_CASE				:int)				-> Dict:






								'''simple docstring'''






								return (increment * self.__hash_function_a(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE)) % self.size_table





		def   _snake_case  (     self				:Tuple ,						_SCREAMING_SNAKE_CASE				:Any ,						_SCREAMING_SNAKE_CASE				:int=None)				-> List[Any]:






								'''simple docstring'''






								UpperCamelCase_    :  Optional[Any]				    =    1
								UpperCamelCase_    :  str				    =    self.hash_function(_SCREAMING_SNAKE_CASE)

								while self.values[new_key] is not None and self.values[new_key] != key:
														UpperCamelCase_    :  int				    =    (
														    self.__hash_double_function(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE)
														    if self.balanced_factor() >= self.lim_charge
														    else None
														)
														if new_key is None:
																				break
														else:
																				i += 1

								return new_key




