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.
The first line contains two positive integers $n, m$ ($1 \leq n, m \leq 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 \leq x, y \leq 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.
In the first sample, the path with largest value is $1 \to 3 \to 4 \to 5$. The value is $3$ because the letter 'a' appears $3$ times.
5 4
abaca
1 2
1 3
3 4
4 5
3
6 6
xzyabc
1 2
3 1
2 3
5 4
4 3
6 4
-1
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
4
1 1
f
1 1
-1
10 50
ebibwbjihv
1 10
1 2
5 4
1 8
9 7
5 6
1 8
8 7
2 6
5 4
1 9
3 2
8 3
5 6
5 9
2 4
2 7
3 9
1 2
1 7
1 10
3 7
1 8
3 10
8 6
1 7
10 6
1 6
5 8
1 5
2 10
3 9
5 8
8 3
3 7
5 2
1 10
1 4
5 3
3 2
1 2
5 8
10 4
2 10
8 2
1 9
1 8
1 2
3 4
1 8
2
13 37
dwpzcppjmhkmz
2 6
3 6
6 7
6 7
6 7
6 7
6 8
6 8
6 8
6 8
4 6
4 6
5 6
4 6
4 6
6 9
6 9
6 10
6 10
6 10
6 10
4 6
1 6
1 6
10 11
6 11
1 6
6 12
6 12
6 12
6 13
6 13
6 13
6 13
3 6
2 6
2 6
3
5 8
tetqw
2 1
4 4
5 5
5 2
4 5
1 5
1 5
1 1
-1
5 8
reeet
4 3
2 5
4 2
2 4
4 2
5 2
3 3
3 4
-1
import math
import sys
from collections import defaultdict
class Graph:
    def _init_(self,vertices):
        self.graph = defaultdict(list)
        self.V=vertices
        
    def addEdge(self,u,v):
        self.graph[u].append(v)
        
    def isCycle(self,n):
        in_degree = [0]*n
        for i in range(n):
            for j in self.graph[i]:
                in_degree[j]+=1
    queue = []
    for i in range(len(in_degree)):
        if in_degree[i]==0
        queue.append(i)
    cnt = 0    
    while(queue):
        nu = queue.pop(0)
        for v in self.graph[nu]:
            in_degree[v]-=1
            if in_degree[v]==0:
                queue.append(v)
        cnt+=1
        if cnt==n:
            return False
        else:
            return True
            
    def dfs(node, adj, dp, vis):
        vis[node] = True
        for i in range(0,len(adj[node])):
            if not vis[adj[node][i]]:
                dfs(adj[node][i], adj, dp, vis)
            dp[node] = max(dp[node],1+dp[adj[node][i]])    
            
    def addEdge(adj,u,v):
        adj[u].append(v)
        
    def find(adj,n):
        dp = [0]*(n+1)
        vis = [False]*(n+1)
        for i in range(1,n+1):
            if not vis[i]:
                dfs(i,adj,dp,vis)
        ans = 0
        for i in range(1,n+1):
            ans = max(ans,dp[i])
        return ans
    if _name_ == "_main_":
        n = int(input())
        m = int(input())
        s = input()
        g = Graph(n)
        for t in range(m):
            x,y = map(int,input().split())
            addEdge(adj,x[i],y[i])
            g.addEdge(x[i],y[i])
        try:
            if g.isCycle(n):
                print("-1")
            else:
                print(find(adj,n))
    except:
        print(find(adj,n))
        

















        