




'''simple docstring'''
import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
							from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

							from .test_feature_extraction_speechta import floats_list


_SCREAMING_SNAKE_CASE =	get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")
@require_torch
class 					__UpperCAmelCase							(    unittest.TestCase							):



					'''simple docstring'''





					def 						__snake_case	(  self    :	List[str])						->       Optional[int]:
								A_       		=   tempfile.mkdtemp()

								A_       		=   SpeechTaTokenizer(_lowercase)
								tokenizer.save_pretrained(self.tmpdirname)

								A_       		=   {
								    'feature_size': 1,
								    'padding_value': 0.0,
								    'sampling_rate': 16_000,
								    'do_normalize': False,
								    'num_mel_bins': 80,
								    'hop_length': 16,
								    'win_length': 64,
								    'win_function': 'hann_window',
								    'fmin': 80,
								    'fmax': 7_600,
								    'mel_floor': 1E-10,
								    'reduction_factor': 2,
								    'return_attention_mask': True,
								}

								A_       		=   os.path.join(self.tmpdirname			,					_lowercase)
								with open(self.feature_extraction_file			,					'w'			,					encoding='utf-8') as fp:
											fp.write(json.dumps(_lowercase) + '\n')



					def 						__snake_case	(  self    :	Any			,					**_lowercase    :	int)						->       str:
								return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,					**_lowercase)



					def 						__snake_case	(  self    :	str			,					**_lowercase    :	Any)						->       Any:
								return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,					**_lowercase)



					def 						__snake_case	(  self    :	Tuple)						->       Optional[int]:
								shutil.rmtree(self.tmpdirname)



					def 						__snake_case	(  self    :	str)						->       str:
								A_       		=   self.get_tokenizer()
								A_       		=   self.get_feature_extractor()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								processor.save_pretrained(self.tmpdirname)
								A_       		=   SpeechTaProcessor.from_pretrained(self.tmpdirname)

								self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer.get_vocab())
								self.assertIsInstance(processor.tokenizer			,					_lowercase)

								self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor.to_json_string())
								self.assertIsInstance(processor.feature_extractor			,					_lowercase)



					def 						__snake_case	(  self    :	Union[str, Any])						->       Optional[Any]:
								A_       		=   SpeechTaProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor())
								processor.save_pretrained(self.tmpdirname)

								A_       		=   self.get_tokenizer(bos_token='(BOS)'			,					eos_token='(EOS)')
								A_       		=   self.get_feature_extractor(do_normalize=_lowercase			,					padding_value=1.0)

								A_       		=   SpeechTaProcessor.from_pretrained(
								    self.tmpdirname			,					bos_token='(BOS)'			,					eos_token='(EOS)'			,					do_normalize=_lowercase			,					padding_value=1.0)

								self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer_add_kwargs.get_vocab())
								self.assertIsInstance(processor.tokenizer			,					_lowercase)

								self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor_add_kwargs.to_json_string())
								self.assertIsInstance(processor.feature_extractor			,					_lowercase)



					def 						__snake_case	(  self    :	Optional[Any])						->       Dict:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								A_       		=   floats_list((3, 1_000))

								A_       		=   feature_extractor(audio=_lowercase			,					return_tensors='np')
								A_       		=   processor(audio=_lowercase			,					return_tensors='np')

								for key in input_feat_extract.keys():
											self.assertAlmostEqual(input_feat_extract[key].sum()			,					input_processor[key].sum()			,					delta=1E-2)



					def 						__snake_case	(  self    :	Union[str, Any])						->       int:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								A_       		=   floats_list((3, 1_000))

								A_       		=   feature_extractor(audio_target=_lowercase			,					return_tensors='np')
								A_       		=   processor(audio_target=_lowercase			,					return_tensors='np')

								for key in input_feat_extract.keys():
											self.assertAlmostEqual(input_feat_extract[key].sum()			,					input_processor[key].sum()			,					delta=1E-2)



					def 						__snake_case	(  self    :	Optional[int])						->       Dict:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								A_       		=   'This is a test string'

								A_       		=   processor(text=_lowercase)
								A_       		=   tokenizer(_lowercase)

								for key in encoded_tok.keys():
											self.assertListEqual(encoded_tok[key]			,					encoded_processor[key])



					def 						__snake_case	(  self    :	str)						->       Optional[int]:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								A_       		=   'This is a test string'

								A_       		=   processor(text_target=_lowercase)
								A_       		=   tokenizer(_lowercase)

								for key in encoded_tok.keys():
											self.assertListEqual(encoded_tok[key]			,					encoded_processor[key])



					def 						__snake_case	(  self    :	Optional[int])						->       str:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								A_       		=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								A_       		=   processor.batch_decode(_lowercase)
								A_       		=   tokenizer.batch_decode(_lowercase)

								self.assertListEqual(_lowercase			,					_lowercase)



					def 						__snake_case	(  self    :	Any)						->       Dict:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=_lowercase			,					feature_extractor=_lowercase)

								self.assertListEqual(
								    processor.model_input_names			,					feature_extractor.model_input_names			,					msg='`processor` and `feature_extractor` model input names do not match'			,					)










'''simple docstring'''
from __future__ import annotations





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





def  lowerCamelCase(       SCREAMING_SNAKE_CASE_    )		->		List[Any]:
			global graph, reversed_graph, scc, component, visit, stack
			if visit[u]:
						return
			A_       		=   True
			component.append(SCREAMING_SNAKE_CASE_    )
			for v in reversed_graph[u]:
						dfsa(SCREAMING_SNAKE_CASE_    )





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


if __name__ == "__main__":
							# n - no of nodes, m - no of edges
							_SCREAMING_SNAKE_CASE ,						_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 ,						_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())




