Dilku was thinking about the first time he met his girl... It was indeed a walk to remember. The romantic weather and her silly talks. He was completely mesmarized. Those were the days!..    

Today is his girl's birthday and he wants to make it special for her. He wants to again take her on a "special walk" that they would remember for the lifetime.    

The city in which Dilku lives is represented as an unweighted directed graph with N nodes and M edges. A "special walk" in the graph starting at node u is a simple path that begins and ends at the same node u.    

Formally, A special walk is path  u , a1 , a2 , a3 ,..., ai ,.... , u  where ai are distinct and not equal to u for all i.

Now since Dilku is really nervous about taking his girl out, he needs your help. For every node in the given graph, tell whether it is possible for Dilku to take his girl on a "special walk" starting at that node.

Input:

First line of a two space separated integers denoting N and M, the number of nodes and number of directed edges in the corresponding graph.       
Following M lines contain two space separated integers  u v  denoting a directed edge in the graph from vertex numbered u to vertex numbered v.

Output:

Print N space separated integers, where ith integer can be either 1 or 0 depicting whether it is possible to go on a special walk starting at node i or not. 

Constraints:
1 ≤ N ≤ 10^5
1 ≤ M ≤ 2 · 10^5
1 ≤ u, v ≤ N

SAMPLE INPUT
5 5
1 2 
2 3 
3 4 
4 5
4 2

SAMPLE OUTPUT
0 1 1 1 0 

Explanation

In the given graph , there is just one directed cycle :  2-->3-->4-->2. Hence, for all nodes on this cycle, the answer is yes and for others the answer is no.
Graph = {}

N, M = map(int, raw_input().split())
for i in xrange(1, N+1):
    Graph[i] = []
for i in xrange(M):
    u, v = map(int, raw_input().split())
    Graph[u].append(v)
    
marked = set()
visit_stack = []
visit_index = {}
parent = {}

dfsPos = 1

oReps = []
oNodes = []
components = [-1]*(N+1)
components_count = {}

def root(s):
    global dfsPos
    components[s] = -dfsPos
    dfsPos+=1
    
    oReps.append(s)
    oNodes.append(s)

def backtrack(a, b):
    if b == oReps[-1]:
        oReps.pop()

        while True:
            c = oNodes.pop()
            components[c] = b
            components_count.setdefault(b, 0)
            components_count[b] += 1 
            if b == c:
                break

def traverse(a, b):
    global dfsPos
    components[b] = -dfsPos
    dfsPos += 1

    oReps.append(b)
    oNodes.append(b)

def traverse_non_tree(a, b):
    if components[b] < 0: # b is in oNodes
        while components[b] > components[oReps[-1]]:
            oReps.pop()

for s in Graph: # all nodes in Graph
    pass
    if s not in marked:
        marked.add(s)
        root(s)
        parent[s] = s
        visit_stack.append(s)
        visit_index[s] = 0
        
        while visit_stack:
            current_node = visit_stack[-1]

            if visit_index[current_node] == len(Graph[current_node]):
                backtrack(parent[current_node], current_node)
                visit_stack.pop()

            else:
                next_node_idx = visit_index[current_node]
                next_node = Graph[current_node][next_node_idx]
                visit_index[current_node] = next_node_idx + 1

                if next_node in marked:
                    traverse_non_tree(current_node, next_node)
                else:
                    marked.add(next_node)
                    parent[next_node] = current_node
                    visit_index[next_node] = 0

                    traverse(current_node, next_node)
                    visit_stack.append(next_node)

        
simple_loop = []
for i in xrange(1, N+1):
    if components_count[components[i]] > 1:
        simple_loop.append(1)
    else:
        simple_loop.append(0)

print " ".join(map(str, simple_loop))