You are given a tree T with n vertices (numbered 1 through n) and a letter in each vertex. The tree is rooted at vertex 1.

Let's look at the subtree Tv of some vertex v. It is possible to read a string along each simple path starting at v and ending at some vertex in Tv (possibly v itself). Let's denote the number of distinct strings which can be read this way as <image>. 

Also, there's a number cv assigned to each vertex v. We are interested in vertices with the maximum value of <image>.

You should compute two statistics: the maximum value of <image> and the number of vertices v with the maximum <image>.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 300 000) — the number of vertices of the tree.

The second line contains n space-separated integers ci (0 ≤ ci ≤ 109).

The third line contains a string s consisting of n lowercase English letters — the i-th character of this string is the letter in vertex i.

The following n - 1 lines describe the tree T. Each of them contains two space-separated integers u and v (1 ≤ u, v ≤ n) indicating an edge between vertices u and v.

It's guaranteed that the input will describe a tree.

Output

Print two lines. 

On the first line, print <image> over all 1 ≤ i ≤ n. 

On the second line, print the number of vertices v for which <image>.

Examples

Input

10
1 2 7 20 20 30 40 50 50 50
cacabbcddd
1 2
6 8
7 2
6 2
5 4
5 9
3 10
2 5
2 3


Output

51
3


Input

6
0 2 4 1 1 1
raaaba
1 2
2 3
2 4
2 5
3 6


Output

6
2

Note

In the first sample, the tree looks like this:

<image>

The sets of strings that can be read from individual vertices are:

<image>

Finally, the values of <image> are:

<image>

In the second sample, the values of <image> are (5, 4, 2, 1, 1, 1). The distinct strings read in T2 are <image>; note that <image> can be read down to vertices 3 or 4.
#include <bits/stdc++.h>
using namespace std;
const int N = 300001;
struct Trie {
  int distinct = 1;
  Trie* links[26] = {NULL};
  int calcDistinct() {
    distinct = 0;
    for (int i = 0; i < 26; i++) {
      if (links[i] != NULL) {
        distinct += links[i]->distinct;
      }
    }
    distinct += 1;
    return distinct;
  }
};
void merge(Trie* A, Trie* B) {
  if (B == NULL) return;
  for (int i = 0; i < 26; i++) {
    if (B->links[i]) {
      A->links[i] = A->links[i] ? A->links[i] : new Trie();
      merge(A->links[i], B->links[i]);
    }
  }
  A->calcDistinct();
}
Trie* T[N];
int A[N];
int S[N];
char s[N];
vector<int> adj[N];
void dfs(int st, int p = -1) {
  S[st] = 1;
  int mx = -1;
  for (auto c : adj[st]) {
    if (c != p) {
      dfs(c, st);
      S[st] += S[c];
      if (mx == -1 || S[mx] < S[c]) mx = c;
    }
  }
  auto root = new Trie();
  if (mx == -1)
    root->links[s[st] - 'a'] = new Trie();
  else {
    for (auto c : adj[st]) {
      if (c != p && c != mx) merge(T[mx], T[c]);
    }
    root->links[s[st] - 'a'] = T[mx];
  }
  root->calcDistinct();
  T[st] = root;
  A[st] += T[st]->distinct - 1;
}
int main() {
  int n;
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d", A + i);
  }
  scanf("%s", s + 1);
  for (int i = 1; i <= n - 1; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  dfs(1);
  map<int, int> M;
  for (int i = 1; i <= n; i++) M[A[i]]++;
  printf("%d\n%d\n", M.rbegin()->first, M.rbegin()->second);
  return 0;
}
