




'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


_SCREAMING_SNAKE_CASE =	{
    "configuration_tvlt": ["TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP", "TvltConfig"],
    "feature_extraction_tvlt": ["TvltFeatureExtractor"],
    "processing_tvlt": ["TvltProcessor"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_SCREAMING_SNAKE_CASE =	[
							    "TVLT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "TvltModel",
							    "TvltForPreTraining",
							    "TvltForAudioVisualClassification",
							    "TvltPreTrainedModel",
							]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_SCREAMING_SNAKE_CASE =	["TvltImageProcessor"]


if TYPE_CHECKING:
							from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
							from .processing_tvlt import TvltProcessor
							from .feature_extraction_tvlt import TvltFeatureExtractor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tvlt import (
														    TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TvltForAudioVisualClassification,
														    TvltForPreTraining,
														    TvltModel,
														    TvltPreTrainedModel,
														)

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_tvlt import TvltImageProcessor


else:
							import sys

							_SCREAMING_SNAKE_CASE =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)










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




