"""simple docstring"""







import argparse
import logging

import datasets
from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import Unigram
from tokenizers.trainers import UnigramTrainer

from transformers import AlbertTokenizerFast


_SCREAMING_SNAKE_CASE	:		str   =   logging.getLogger(__name__)



def       A__    (	)  ->							Tuple:
   __lowerCamelCase    		=					argparse.ArgumentParser(description='Train a unigram tokenizer on the wikitext dataset.'						)
   parser.add_argument(
       '--dataset_name'      , type=UpperCAmelCase__      , default='wikitext'      , help='Name of the training. Explore datasets at: hf.co/datasets.'      , )
   parser.add_argument(
       '--dataset_config'      , type=UpperCAmelCase__      , default='wikitext-103-raw-v1'      , help='Configuration name of the dataset.'						)
   parser.add_argument(
       '--batch_size'      , type=UpperCAmelCase__      , default=1000      , help='Batch size during training.'      , )
   parser.add_argument(
       '--vocab_size'      , type=UpperCAmelCase__      , default=10048      , help='Size of the desired vocabulary.'      , )
   parser.add_argument(
       '--limit'      , default=UpperCAmelCase__      , type=UpperCAmelCase__      , help='Limit the number of shards (used for debugging).'      , )
   parser.add_argument(
       '--export_to_hub'      , action='store_true'      , )

   __lowerCamelCase    		=					parser.parse_args()
   return args



def       A__    (	lowercase_     :	Optional[int]						)  ->							List[Any]:
   __lowerCamelCase    		=					datasets.load_dataset(args.dataset_name      , args.dataset_config      , split='train'						)

   if args.limit is not None:
      __lowerCamelCase    		=					min(len(UpperCAmelCase__						)      , args.limit						)
      __lowerCamelCase    		=					dataset.select(range(UpperCAmelCase__						)						)
      logger.info(F'''Limiting the dataset to {args.limit} entries.'''						)

   def batch_iterator():
      for i in range(0      , len(UpperCAmelCase__						)      , args.batch_size						):
         yield dataset[i : i + args.batch_size]["text"]

    # Prepare the tokenizer.
   __lowerCamelCase    		=					Tokenizer(Unigram()						)
   __lowerCamelCase    		=					normalizers.Sequence([normalizers.Replace('``'      , '\"'						), normalizers.Replace('\'\''      , '\"'						)]						)
   __lowerCamelCase    		=					pre_tokenizers.Metaspace()

   # Prepare the trainer.
   __lowerCamelCase    		=					UnigramTrainer(
       unk_token='<unk>'      , special_tokens=['[CLS]', '[SEP]', '<unk>', '<pad>', '[MASK]']      , vocab_size=args.vocab_size      , )

   logger.info('Training the tokenizer.'						)
   tokenizer.train_from_iterator(batch_iterator()      , trainer=UpperCAmelCase__						)
   logger.info('Tokenizer training complete!'						)

   __lowerCamelCase    		=					tokenizer.token_to_id('[CLS]'						)
   __lowerCamelCase    		=					tokenizer.token_to_id('[SEP]'						)
   __lowerCamelCase    		=					processors.TemplateProcessing(
       single='[CLS]:0 $A:0 [SEP]:0'      , pair='[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1'      , special_tokens=[
           ('[CLS]', cls_token_id),
           ('[SEP]', sep_token_id),
       ]      , )
   __lowerCamelCase    		=					decoders.Metaspace()

   if args.export_to_hub:
      logger.info('Exporting the trained tokenzier to Hub.'						)
      __lowerCamelCase    		=					AlbertTokenizerFast(tokenizer_object=UpperCAmelCase__						)
      new_tokenizer.push_to_hub('unigram-tokenizer-dataset'						)


if __name__ == "__main__":
     _SCREAMING_SNAKE_CASE	:		Dict   =   parse_args()
     main(args)







'''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())





