

"""simple docstring"""





from __future__ import annotations



def        _lowerCAmelCase      (						UpperCAmelCase     :							int				):


					'''simple docstring'''






					global graph, reversed_graph, scc, component, visit, stack
					if visit[u]:
										return
					UpperCamelCase__		:    Tuple         =True
					for v in graph[u]:
										dfs(_UpperCAmelCase				)
					stack.append(_UpperCAmelCase				)



def        _lowerCAmelCase      (						UpperCAmelCase     :							str				):


					'''simple docstring'''






					global graph, reversed_graph, scc, component, visit, stack
					if visit[u]:
										return
					UpperCamelCase__		:    List[str]         =True
					component.append(_UpperCAmelCase				)
					for v in reversed_graph[u]:
										dfsa(_UpperCAmelCase				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					global graph, reversed_graph, scc, component, visit, stack
					for i in range(_UpperCAmelCase				):
										dfs(_UpperCAmelCase				)
					UpperCamelCase__		:    str         =[False] * n
					for i in stack[::-1]:
										if visit[i]:
															continue
										UpperCamelCase__		:    Dict         =[]
										dfsa(_UpperCAmelCase				)
										scc.append(_UpperCAmelCase				)
					return scc


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

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

				_SCREAMING_SNAKE_CASE       :  list[int]        = []
				_SCREAMING_SNAKE_CASE       :  list[bool]        = [False] * n
				_SCREAMING_SNAKE_CASE       :  list[int]        = []
				_SCREAMING_SNAKE_CASE       :  list[int]        = []
				print(kosaraju())





"""simple docstring"""





import unittest

from transformers.image_processing_utils import get_size_dict

class     __a   (      unittest.TestCase    ):

			"""simple docstring"""

			def    _lowerCAmelCase			(							self     :					Dict						):
								# Test a dict with the wrong keys raises an error
								UpperCamelCase__		:    str         ={'''wrong_key''': 224}
								with self.assertRaises(lowercase_						):
													get_size_dict(lowercase_						)

								UpperCamelCase__		:    Any         ={'''height''': 224}
								with self.assertRaises(lowercase_						):
													get_size_dict(lowercase_						)

								UpperCamelCase__		:    List[str]         ={'''width''': 224, '''shortest_edge''': 224}
								with self.assertRaises(lowercase_						):
													get_size_dict(lowercase_						)

								# Test a dict with the correct keys is returned as is
								UpperCamelCase__		:    int         ={'''height''': 224, '''width''': 224}
								UpperCamelCase__		:    str         =get_size_dict(lowercase_						)
								self.assertEqual(lowercase_						,  lowercase_						)

								UpperCamelCase__		:    List[Any]         ={'''shortest_edge''': 224}
								UpperCamelCase__		:    List[str]         =get_size_dict(lowercase_						)
								self.assertEqual(lowercase_						,  {'''shortest_edge''': 224}						)

								UpperCamelCase__		:    List[Any]         ={'''longest_edge''': 224, '''shortest_edge''': 224}
								UpperCamelCase__		:    Tuple         =get_size_dict(lowercase_						)
								self.assertEqual(lowercase_						,  {'''longest_edge''': 224, '''shortest_edge''': 224}						)

								# Test a single int value which  represents (size, size)
								UpperCamelCase__		:    Optional[int]         =get_size_dict(224						)
								self.assertEqual(lowercase_						,  {'''height''': 224, '''width''': 224}						)

								# Test a single int value which represents the shortest edge
								UpperCamelCase__		:    str         =get_size_dict(224						,  default_to_square=lowercase_						)
								self.assertEqual(lowercase_						,  {'''shortest_edge''': 224}						)

								# Test a tuple of ints which represents (height, width)
								UpperCamelCase__		:    List[str]         =get_size_dict((150, 200)						)
								self.assertEqual(lowercase_						,  {'''height''': 150, '''width''': 200}						)

								# Test a tuple of ints which represents (width, height)
								UpperCamelCase__		:    Optional[int]         =get_size_dict((150, 200)						,  height_width_order=lowercase_						)
								self.assertEqual(lowercase_						,  {'''height''': 200, '''width''': 150}						)

								# Test an int representing the shortest edge and max_size which represents the longest edge
								UpperCamelCase__		:    int         =get_size_dict(224						,  max_size=256						,  default_to_square=lowercase_						)
								self.assertEqual(lowercase_						,  {'''shortest_edge''': 224, '''longest_edge''': 256}						)

								# Test int with default_to_square=True and max_size fails
								with self.assertRaises(lowercase_						):
													get_size_dict(224						,  max_size=256						,  default_to_square=lowercase_						)


