You are given a graph with n nodes and m directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is 3. Your task is find a path whose value is the largest.

Input

The first line contains two positive integers n, m (1 ≤ n, m ≤ 300 000), denoting that the graph has n nodes and m directed edges.

The second line contains a string s with only lowercase English letters. The i-th character is the letter assigned to the i-th node.

Then m lines follow. Each line contains two integers x, y (1 ≤ x, y ≤ n), describing a directed edge from x to y. Note that x can be equal to y and there can be multiple edges between x and y. Also the graph can be not connected.

Output

Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.

Examples

Input

5 4
abaca
1 2
1 3
3 4
4 5


Output

3


Input

6 6
xzyabc
1 2
3 1
2 3
5 4
4 3
6 4


Output

-1


Input

10 14
xzyzyzyzqx
1 2
2 4
3 5
4 5
2 6
6 8
6 5
2 10
3 9
10 9
4 6
1 10
2 8
3 7


Output

4

Note

In the first sample, the path with largest value is 1 → 3 → 4 → 5. The value is 3 because the letter 'a' appears 3 times.
import java.io.*;
import java.util.*;

public class utkarsh{
	InputStream is;
	PrintWriter out;

	int n, m, vst[], ans[], dp;
	char t, c[];
	ArrayList <Integer> a[];
	boolean cycle, f[];

	void read() {
		n = ni();
		m = ni();
		c = ns().toCharArray();
		f = new boolean[26];
		for(int i = 0; i < n; i++) {
			f[c[i] - 'a'] = true;
		}
		a = new ArrayList[n];
		cycle = false;
		for(int i = 0; i < n; i++) {
			a[i] = new ArrayList<>();
		}
		for(int i = 0; i < m; i++) {
			int u = ni() - 1;
			int v = ni() - 1;
			if(u == v)	cycle = true;
			a[u].add(v);
		}
		vst = new int[n];
		ans = new int[n];
	}

	int dfs(int s) {
		if(vst[s] > 0)	return ans[s];
		vst[s] = 1;
		int d = 0;
		for(int x : a[s]) {
			if(vst[x] == 1) {
				cycle = true;
				return -1;
			}
			d = Math.max(d, dfs(x));
		}
		if(c[s] == t)	d++;
		ans[s] = d;
		if(d > dp)	dp = d;
		vst[s] = 2;
		return d;
	}

	void solve(){
		read();
		if(cycle) {
			out.println(-1);
			return;
		}
		for(t = 'a'; t <= 'z'; t++) {
			if(!f[t - 'a'])	continue;
			Arrays.fill(vst, 0);
			Arrays.fill(ans, 0);
			for(int i = 0; i < n; i++) {
				if(vst[i] == 0) {
					dfs(i);
				}
				if(cycle) {
					out.println(-1);
					return;
				}
			}
		}
		out.println(dp);
	}

	void run() { 
        is = System.in; 
        out = new PrintWriter(System.out); 

        solve(); 
        out.flush();
    }
    public static void main(String[] args) { 
        new utkarsh().run();
    }
    
    byte input[] = new byte[1024];
    int len = 0, ptr = 0;
    
    int readByte() { 
        if(ptr >= len) { ptr = 0; 
            try { len = is.read(input); }
            catch(IOException e) { throw new InputMismatchException(); } 
            if(len <= 0){ return -1; } 
        } return input[ptr++];
    }
    boolean isSpaceChar(int c) { 
        return !( c >= 33 && c <= 126 ); 
    }
    int skip(){ 
        int b = readByte(); 
        while(b != -1 && isSpaceChar(b)) { b = readByte(); } 
        return b;
    }
    
    char nc(){ return (char)skip();
    }
    String ns() { 
        int b = skip(); StringBuilder sb = new StringBuilder(); 
        while(!isSpaceChar(b)) { sb.appendCodePoint(b); b=readByte(); } 
        return sb.toString();
    }
    int ni() { 
        int n = 0, b = readByte(); boolean minus = false; 
        while(b != -1 && !( (b >= '0' && b <= '9') || b == '-')) { b = readByte(); } 
        if(b == '-') { minus = true; b = readByte(); } 
        if(b == -1) { return -1; } 
        while(b >= '0' && b <= '9') { n = n * 10 + (b - '0'); b = readByte(); } 
        return minus ? -n : n;
    }
}