import hashlib
import importlib.util
import json
import os
import pathlib
from types import ModuleType

import pytest
import requests

_SCREAMING_SNAKE_CASE   		=			pathlib.Path.cwd().joinpath("""project_euler""")
_SCREAMING_SNAKE_CASE   		=			pathlib.Path.cwd().joinpath(
    """scripts""", """project_euler_answers.json"""
)

with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
     _SCREAMING_SNAKE_CASE   		=			json.load(file_handle)





def  lowercase(  UpperCamelCase_					)		->  Union[str, Any]:







 '''simple docstring'''
 UpperCamelCase      =			importlib.util.spec_from_file_location(file_path.name       ,				str(_A					)					)
 UpperCamelCase      =			importlib.util.module_from_spec(_A					)  # type: ignore
 spec.loader.exec_module(_A					)  # type: ignore
 return module





def  lowercase(  )		->  Optional[int]:







 '''simple docstring'''
 UpperCamelCase      =			[]
 for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
  if problem_dir_path.is_file() or problem_dir_path.name.startswith("""_"""					):
   continue
  for file_path in problem_dir_path.iterdir():
   if file_path.suffix != ".py" or file_path.name.startswith(("""_""", """test""")					):
    continue
   solution_file_paths.append(_A					)
 return solution_file_paths





def  lowercase(  )		->  Optional[int]:







 '''simple docstring'''


 with open(os.environ["""GITHUB_EVENT_PATH"""]					) as file:
  UpperCamelCase      =			json.load(_A					)
 return event["pull_request"]["url"] + "/files"





def  lowercase(  )		->  List[str]:







 '''simple docstring'''
 UpperCamelCase      =			[]
 UpperCamelCase      =			{
     """Accept""": """application/vnd.github.v3+json""",
     """Authorization""": """token """ + os.environ["""GITHUB_TOKEN"""],
 }
 UpperCamelCase      =			requests.get(get_files_url()       ,				headers=_A					).json()
 for file in files:
  UpperCamelCase      =			pathlib.Path.cwd().joinpath(file["""filename"""]					)
  if (
      filepath.suffix != ".py"
      or filepath.name.startswith(("""_""", """test""")					)
      or not filepath.name.startswith("""sol"""					)
  ):
   continue
  solution_file_paths.append(_A					)
 return solution_file_paths





def  lowercase(  )		->  Any:







 '''simple docstring'''


 if os.environ.get("""CI"""					) and os.environ.get("""GITHUB_EVENT_NAME"""					) == "pull_request":
  # Return only if there are any, otherwise default to all solutions
  if filepaths := added_solution_file_path():
   return filepaths
 return all_solution_file_paths()





@pytest.mark.parametrize(
    """solution_path"""       ,				collect_solution_file_paths()       ,				ids=lambda UpperCamelCase_					: f"""{path.parent.name}/{path.name}"""       ,				)
def  lowercase(  UpperCamelCase_					)		->  Dict:







 '''simple docstring'''
 UpperCamelCase      =			solution_path.parent.name[8:].zfill(3					)
 UpperCamelCase      =			PROBLEM_ANSWERS[problem_number]
 UpperCamelCase      =			convert_path_to_module(_A					)
 UpperCamelCase      =			str(solution_module.solution()					)  # type: ignore
 UpperCamelCase      =			hashlib.shaaaa(answer.encode()					).hexdigest()
 assert (
     answer == expected
 ), f"""Expected solution to {problem_number} to have hash {expected}, got {answer}"""

from __future__ import annotations





def  lowercase(  UpperCamelCase_					)		->  Dict:







 '''simple docstring'''
 global graph, reversed_graph, scc, component, visit, stack
 if visit[u]:
  return
 UpperCamelCase      =			True
 for v in graph[u]:
  dfs(UpperCamelCase_					)
 stack.append(UpperCamelCase_					)





def  lowercase(  UpperCamelCase_					)		->  Optional[int]:







 '''simple docstring'''
 global graph, reversed_graph, scc, component, visit, stack
 if visit[u]:
  return
 UpperCamelCase      =			True
 component.append(UpperCamelCase_					)
 for v in reversed_graph[u]:
  dfsa(UpperCamelCase_					)





def  lowercase(  )		->  Any:







 '''simple docstring'''
 global graph, reversed_graph, scc, component, visit, stack
 for i in range(UpperCamelCase_					):
  dfs(UpperCamelCase_					)
 UpperCamelCase      =			[False] * n
 for i in stack[::-1]:
  if visit[i]:
   continue
  UpperCamelCase      =			[]
  dfsa(UpperCamelCase_					)
  scc.append(UpperCamelCase_					)
 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())
