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 
/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;


/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
         static class Input {
        private StringTokenizer tokenizer = null;
        private BufferedReader reader;
 
        public Input(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }
 
        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
 
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(nextLine());
            }
            return tokenizer.nextToken();
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
 
        public int[] nextIntArray(int n, int add) {
            int[] result = new int[n];
            for (int i = 0; i < n; i++) {
                result[i] = nextInt() + add;
            }
            return result;
        }
 
        public long[] nextLongArray(int n, long add) {
            long[] result = new long[n];
            for (int i = 0; i < n; i++) {
                result[i] = nextLong() + add;
            }
            return result;
        }
 
        public int[] nextIntArray(int n) {
            return nextIntArray(n, 0);
        }
 
    }
    
    static int visited[];
    static ArrayList<Integer> a[];
    static boolean cycle=false;
    static void dfs(int v)
    {
        visited[v]=1;
        for(Integer i:a[v])
        {
            if(visited[i]==1)
            {cycle=true;
             //System.out.println(v+" "+i);
            }
            else if(visited[i]==0)
            dfs(i);
        }
        visited[v]=2;
    }
    
    
    
	public static void main (String[] args) throws java.lang.Exception
	{
		Input s=new Input(System.in);
		int t=1;
		PrintWriter out=new PrintWriter(System.out);
		
		while(t-->0)
		{
		    int n=s.nextInt();
		    int m=s.nextInt();
		    a=new ArrayList[n];
		    for(int i=0;i<n;i++)
		    a[i]=new ArrayList<>();
		    ArrayList<Integer> p=new ArrayList<>();
		    
		    
		    
		    for(int i=0;i<m;i++)
		    {
		        int u=s.nextInt()-1;
		        int v=s.nextInt()-1;
		        a[u].add(v);
		        p.add(u);
		        p.add(v);
		    }
		    cycle=false;
		    visited=new int[n];
		    for(int i=0;i<n;i++)
		    if(visited[i]==0)
		    dfs(i);
		    
		    if(!cycle)
		    { System.out.println(1);
		     for(int i=0;i<m;i++)
		      System.out.print(1+" ");
		    }else
		    {   
		        System.out.println(2);
		        for(int i=0;i<m;i++)
		        {
		            if(p.get(2*i)<p.get(2*i+1))
		            System.out.print(1+" ");
		            else
		            System.out.print(2+" ");
		        }
		    }
		    
		} 
	}
}
