


"""simple docstring"""
import os
from shutil import copyfile
from typing import Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
			from .tokenization_reformer import ReformerTokenizer
else:
			SCREAMING_SNAKE_CASE					:       Union[str, Any]							   =							None


SCREAMING_SNAKE_CASE					:       int							   =							logging.get_logger(__name__)


SCREAMING_SNAKE_CASE					:       Union[str, Any]							   =							"""▁"""

SCREAMING_SNAKE_CASE					:       Optional[int]							   =							{"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

SCREAMING_SNAKE_CASE					:       Tuple							   =							{
    """vocab_file""": {
        """google/reformer-crime-and-punishment""": (
            """https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model"""
        )
    },
    """tokenizer_file""": {
        """google/reformer-crime-and-punishment""": (
            """https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/tokenizer.json"""
        )
    },
}

SCREAMING_SNAKE_CASE					:       List[Any]							   =							{
    """google/reformer-crime-and-punishment""": 52_4288,
}



class      _UpperCAmelCase					(				__snake_case							):






		'''simple docstring'''

		lowerCamelCase__           =VOCAB_FILES_NAMES
		lowerCamelCase__           =PRETRAINED_VOCAB_FILES_MAP
		lowerCamelCase__           =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCamelCase__           =['input_ids', 'attention_mask']
		lowerCamelCase__           =ReformerTokenizer



		def __init__(self							,			a_=None							,			a_=None							,			a_="</s>"							,			a_="<unk>"							,			a_=[]							,			**a_							,			):





			'''simple docstring'''

			super().__init__(
			    a_							,			tokenizer_file=a_							,			eos_token=a_							,			unk_token=a_							,			additional_special_tokens=a_							,			**a_							,			)

			__snake_case      :		List[Any]         =							vocab_file
			__snake_case      :		Any         =							False if not self.vocab_file else True



		def 							SCREAMING_SNAKE_CASE    (self							,			a_							,			a_ = None   ):





			'''simple docstring'''

			if not self.can_save_slow_tokenizer:
				raise ValueError(
				    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
				    '''tokenizer.'''   )

			if not os.path.isdir(a_   ):
				logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""   )
				return
			__snake_case      :		Union[str, Any]         =							os.path.join(
			    a_							,			(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']   )

			if os.path.abspath(self.vocab_file   ) != os.path.abspath(a_   ):
				copyfile(self.vocab_file							,			a_   )

			return (out_vocab_file,)






'''simple docstring'''




from __future__ import annotations




def 				lowerCamelCase      ( UpperCAmelCase__			:   str					)     -> Any:
							global graph, reversed_graph, scc, component, visit, stack
							if visit[u]:
														return
							lowercase_   :     int									=			True
							for v in graph[u]:
														dfs(UpperCAmelCase__					)
							stack.append(UpperCAmelCase__					)




def 				lowerCamelCase      ( UpperCAmelCase__			:   int					)     -> str:
							global graph, reversed_graph, scc, component, visit, stack
							if visit[u]:
														return
							lowercase_   :     Tuple									=			True
							component.append(UpperCAmelCase__					)
							for v in reversed_graph[u]:
														dfsa(UpperCAmelCase__					)




def 				lowerCamelCase      ( )     -> int:
							global graph, reversed_graph, scc, component, visit, stack
							for i in range(UpperCAmelCase__					):
														dfs(UpperCAmelCase__					)
							lowercase_   :     Optional[int]									=			[False] * n
							for i in stack[::-1]:
														if visit[i]:
																					continue
														lowercase_   :     Union[str, Any]									=			[]
														dfsa(UpperCAmelCase__					)
														scc.append(UpperCAmelCase__					)
							return scc


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

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

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





