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 collections
a = input().split()
m = int(a[0])
n = int(a[1])
s = list(input())

d = {}
for i in range(n):
    b = input().split()
    if int(b[0]) not in d:
        d[int(b[0])] = [int(b[1])]
    else:
        d[int(b[0])].append(int(b[1]))

def dfs(d, so, visited, di, string, freq=0, mmax=0):
    if visited is None:
        visited = []
    visited.append(so)
    #     print(visited)
    #     print(s, end='->')
    di[string[so - 1]] += 1
    #     print(di, so)
    if so not in d:
        if max(di.values()) > freq:
            freq = max(di.values())
        #             print(so, 'ooo')
        di[string[so - 1]] -= 1
        visited.pop()
        if freq > mmax:
            return freq
        else:
            return mmax

    #     print(string[so-1])

    for next in d[so]:
        if next not in visited:
            #             m = mmax
            #             print(mmax, "MMAX")
            m = dfs(d, next, visited, di, string, freq, mmax)
            mmax = m
    di[string[so - 1]] -= 1
    visited.pop()
    #     print(visited)
    try:
        return m
    except:
        return 0


def iscycle(d, s, visited=None):
    if visited == None:
        visited = []
    visited.append(s)

    # print(s, end = '->')
    if s not in d:
        return
    for next in d[s]:
        if next in visited:
            return True
        if next not in visited:
            return (iscycle(d, next, visited))


def maxPathValue(n, m, d, s):

    di = {}
    for ch in s:
        if ch not in di:
            di[ch] = 0
    #     print(di)


    if (iscycle(d, list(d.keys())[0])):
        return -1
    mval = 1
    #     print(d)
    for j in range(len(list(d.keys()))):
        #         print('------------')
        mval = max(mval, dfs(d, list(d.keys())[j], None, di, s))
    #         print(mval, "MVAL")
    #         print('------------')

    return (mval)

m = maxPathValue(n, m, d, s)
print(m)