




'''simple docstring'''
from __future__ import annotations
def 							snake_case_    (  a__						:      Optional[Any]     ):



    """simple docstring"""




    global graph, reversed_graph, scc, component, visit, stack
    if visit[u]:
        return
    __lowercase     							=		True
    for v in graph[u]:
        dfs(a__     )
    stack.append(a__     )
def 							snake_case_    (  a__						:      str     ):



    """simple docstring"""




    global graph, reversed_graph, scc, component, visit, stack
    if visit[u]:
        return
    __lowercase     							=		True
    component.append(a__     )
    for v in reversed_graph[u]:
        dfsa(a__     )
def 							snake_case_    (  ):



    """simple docstring"""




    global graph, reversed_graph, scc, component, visit, stack
    for i in range(a__     ):
        dfs(a__     )
    __lowercase     							=		[False] * n
    for i in stack[::-1]:
        if visit[i]:
            continue
        __lowercase     							=		[]
        dfsa(a__     )
        scc.append(a__     )
    return scc


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

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

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










'''simple docstring'''
def 							snake_case_    (  a__						:      List[str]       ,a__						:      Optional[int]     ):



    """simple docstring"""




    __lowercase     							=		(boundary[1] - boundary[0]) / steps
    __lowercase     							=		boundary[0]
    __lowercase     							=		boundary[1]
    __lowercase     							=		make_points(a__       ,a__       ,a__     )
    __lowercase     							=		0.0
    y += (h / 3.0) * f(a__     )
    __lowercase     							=		2
    for i in x_i:
        y += (h / 3) * (4 - 2 * (cnt % 2)) * f(a__     )
        cnt += 1
    y += (h / 3.0) * f(a__     )
    return y
def 							snake_case_    (  a__						:      Optional[Any]       ,a__						:      List[str]       ,a__						:      Optional[Any]     ):



    """simple docstring"""




    __lowercase     							=		a + h
    while x < (b - h):
        yield x
        __lowercase     							=		x + h
def 							snake_case_    (  a__						:      List[Any]     ):  # enter your function here



    """simple docstring"""




    __lowercase     							=		(x - 0) * (x - 0)
    return y
def 							snake_case_    (  ):



    """simple docstring"""




    __lowercase     							=		0.0  # Lower bound of integration
    __lowercase     							=		1.0  # Upper bound of integration
    __lowercase     							=		1_0.0  # define number of steps or resolution
    __lowercase     							=		[a, b]  # define boundary of integration
    __lowercase     							=		method_a(a__       ,a__     )
    print(f'y = {y}'     )


if __name__ == "__main__":
  main()




