Problem: You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.

Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.

Find a good k-coloring of given digraph with minimum possible k.

Input

The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.

Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.

It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.

Output

In the first line print single integer k — the number of used colors in a good k-coloring of given graph.

In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).

If there are multiple answers print any of them (you still have to minimize k).

Examples

Input


4 5
1 2
1 3
3 4
2 4
1 4


Output


1
1 1 1 1 1 


Input


3 3
1 2
2 3
3 1


Output


2
1 1 2 

Solution (in PYTHON):

Solution:
import sys
from collections import deque
range = xrange
input = raw_input

inp = [int(x) for x in sys.stdin.read().split()]
ii = 0

n = inp[ii]
ii += 1
m = inp[ii]
ii += 1

coupl = [[] for _ in range(n)]
for _ in range(m):
    u = inp[ii] - 1
    ii += 1
    v = inp[ii] - 1
    ii += 1
    coupl[u].append(v)


found = [0]*n
indeg = [0]*n

order = []
for root in range(n):
    if found[root]:
        continue
    tmp = []
    
    dfs = []
    dfs.append(root)
    while dfs:
        node = dfs.pop()
        if node < 0:
            tmp.append(~node)
            continue
        if found[node]:
            continue
        found[node] = 1
        dfs.append(~node)
        for nei in coupl[node]:
            dfs.append(nei)
    order += tmp

index = [0]*n
for i in range(n):
    index[order[i]] = i

ii = 2
out = [1]*m
for _ in range(m):
    u = inp[ii] - 1
    ii += 1
    v = inp[ii] - 1
    ii += 1
    if index[u] < index[v]:
        out[_] = 2
print 2 if any(o == 2 for o in out) else 1
print ' '.join(str(o) for o in out)