Problem: Mr. Endo wanted to write the code that performs breadth-first search (BFS), which is a search algorithm to explore all vertices on a directed graph. An example of pseudo code of BFS is as follows:


1: $current \leftarrow \{start\_vertex\}$
2: $visited \leftarrow current$
3: while $visited \ne$ the set of all the vertices
4:   $found \leftarrow \{\}$
5:   for $u$ in $current$
6:     for each $v$ such that there is an edge from $u$ to $v$
7:       $found \leftarrow found \cup \{v\}$
8:   $current \leftarrow found \setminus visited$
9:   $visited \leftarrow visited \cup found$


However, Mr. Endo apparently forgot to manage visited vertices in his code. More precisely, he wrote the following code:


1: $current \leftarrow \{start\_vertex\}$
2: while $current \ne$ the set of all the vertices
3:   $found \leftarrow \{\}$
4:   for $u$ in $current$
5:     for each $v$ such that there is an edge from $u$ to $v$
6:       $found \leftarrow found \cup \{v\}$
7:   $current \leftarrow found$


You may notice that for some graphs, Mr. Endo's program will not stop because it keeps running infinitely. Notice that it does not necessarily mean the program cannot explore all the vertices within finite steps. Your task here is to make a program that determines whether Mr. Endo's program will stop within finite steps for a given directed graph in order to point out the bug to him. Also, calculate the minimum number of loop iterations required for the program to stop if it is finite. Since the answer might be huge, thus print the answer modulo $10^9 +7$, which is a prime number.



Input

The input consists of a single test case formatted as follows.


$N$ $M$
$u_1$ $v_1$
:
$u_M$ $v_M$


The first line consists of two integers $N$ ($2 \leq N \leq 500$) and $M$ ($1 \leq M \leq 200,000$), where $N$ is the number of vertices and $M$ is the number of edges in a given directed graph, respectively. The $i$-th line of the following $M$ lines consists of two integers $u_i$ and $v_i$ ($1 \leq u_i, v_i \leq N$), which means there is an edge from $u_i$ to $v_i$ in the given graph. The vertex $1$ is the start vertex, i.e. $start\\_vertex$ in the pseudo codes. You can assume that the given graph also meets the following conditions.

* The graph has no self-loop, i.e., $u_i \ne v_i$ for all $1 \leq i \leq M$.
* The graph has no multi-edge, i.e., $(u_i, v_i) \le (u_j, v_j)$ for all $1 \leq i < j \leq M$.
* For each vertex $v$, there is at least one path from the start vertex $1$ to $v$.

Output

If Mr. Endo's wrong BFS code cannot stop within finite steps for the given input directed graph, print '-1' in a line. Otherwise, print the minimum number of loop iterations required to stop modulo $10^9+7$.

Examples

Input

4 4
1 2
2 3
3 4
4 1


Output

-1


Input

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


Output

7


Input

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


Output

3

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



#define SIZE 505

int V,E;
int root = 0;
int POW[20],pow_max = 0;
bool can_visit[20][SIZE][SIZE],check[2][SIZE];


bool isOK(int count){

	int CURRENT = 0,NEXT = 1;
	for(int i = 0; i < V; i++){
		check[CURRENT][i] = false;
		check[NEXT][i] = false;
	}

	bool FLG;

	check[CURRENT][root] = true;

	for(int i = pow_max; i >= 0; i--){
		if(POW[i] > count)continue;
		count -= POW[i];

		for(int k = 0; k < V; k++){
			if(!check[CURRENT][k])continue;


			for(int p = 0; p < V; p++){
				if(can_visit[i][k][p]){

					check[NEXT][p] = true;
				}
			}
		}

		FLG = true;
		for(int k = 0; k < V; k++){
			if(!check[NEXT][k]){
				FLG = false;
				break;
			}
		}

		if(FLG)return true;

		swap(CURRENT,NEXT);
		for(int k = 0; k < V; k++){

			check[NEXT][k] = false;
		}
	}

	return false;
}


int main(){

	scanf("%d %d",&V,&E);

	POW[0] = 1;
	for(int i = 1; i <= 19; i++){

		POW[i] = POW[i-1]*2;
	}

	for(int i = 0; i <= 19; i++){
		if(POW[i] > V*V+(V+5)){
			pow_max = i;
			break;
		}
	}

	for(int i = 0; i <= pow_max; i++){
		for(int from = 0; from < V; from++){
			for(int to = 0; to < V; to++){

				can_visit[i][from][to] = false;
			}
		}
	}

	int from,to;
	for(int loop = 0; loop < E; loop++){

		scanf("%d %d",&from,&to);
		from--;
		to--;
		can_visit[0][from][to] = true;
	}

	for(int i = 1; i <= pow_max; i++){
		for(int a = 0; a < V; a++){
			for(int b = 0; b < V; b++){
				if(!can_visit[i-1][a][b])continue;
				for(int c = 0; c < V; c++){
					if(!can_visit[i-1][b][c])continue;
					can_visit[i][a][c] = true;
				}
			}
		}
	}

	int left = 0,right = V*V+V+5,mid = (left+right)/2;
	int ans = BIG_NUM;

	while(left <= right){

		if(isOK(mid)){

			ans = mid;
			right = mid-1;
		}else{

			left = mid+1;
		}
		mid = (left+right)/2;
	}

	if(ans == BIG_NUM){

		printf("-1\n");
	}else{

		printf("%d\n",ans);
	}

	return 0;
}