Toad Ilya has a rooted binary tree with vertex 1 being the root. A tree is a connected graph without cycles. A tree is rooted if one vertex is selected and called the root. A vertex u is a child of a vertex v if u and v are connected by an edge and v is closer to the root than u. A leaf is a non-root vertex that has no children.

In the tree Ilya has each vertex has at most two children, and each edge has some character written on it. The character can be a lowercase English letter or the question mark '?'.

Ilya will q times update the tree a bit. Each update will replace exactly one character on some edge. After each update Ilya needs to find if the tree is anagrammable and if yes, find its anagramnity for each letter. Well, that's difficult to explain, but we'll try.

To start with, a string a is an anagram of a string b if it is possible to rearrange letters in a (without changing the letters itself) so that it becomes b. For example, the string "fortyfive" is an anagram of the string "overfifty", but the string "aabb" is not an anagram of the string "bbba".

Consider a path from the root of the tree to a leaf. The characters on the edges on this path form a string, we say that this string is associated with this leaf. The tree is anagrammable if and only if it is possible to replace each question mark with a lowercase English letter so that for all pair of leaves the associated strings for these leaves are anagrams of each other.

If the tree is anagrammable, then its anagramnity for the letter c is the maximum possible number of letters c in a string associated with some leaf in a valid replacement of all question marks.

Please after each update find if the tree is anagrammable and if yes, find the ∑{f(c) ⋅ ind(c)} for all letters c, where f(c) is the anagramnity for the letter c, and ind(x) is the index of this letter in the alphabet (ind("a") = 1, ind("b") = 2, ..., ind("z") = 26).

Input

The first line of input contains two integers n and q (2 ≤ n ≤ 150 000, 1 ≤ q ≤ 150 000) — the number of vertices in the tree and the number of queries.

The next n-1 lines describe the initial tree. The i-th of them contains an integer p_i and a character c_i (1 ≤ p_i ≤ i, c_i is a lowercase English letter or the question mark '?') describing an edge between vertices p_i and i+1 with character c_i written on it.

The root of this tree is the vertex 1, and each vertex has at most two children.

The next q lines describe the queries. The i-th of them contains two integers v and c (2 ≤ v ≤ n, c is a lowercase English letter or the question mark '?'), meaning that updated character on the edge between p_{v-1} to v is c. The updated character can be the same as was written before.

Output

Output q lines. In the i-th of them print "Fou" if the tree is not anagrammable after the first i updates.

Otherwise output "Shi" and the ∑{f(c) ⋅ ind(c)} for all letters c.

Examples

Input


3 4
1 ?
1 ?
2 ?
2 a
3 b
2 b


Output


Shi 351
Shi 1
Fou
Shi 2


Input


5 2
1 ?
1 ?
2 ?
3 ?
4 a
5 b


Output


Shi 352
Shi 3

Note

In the first example after the first query, for each character, you can set all edges equal to that character, and you will get 1 such character on each path, so the answer is 1 ⋅ (1+2+…+26) = 351.

In the first example after the second query, you know that all paths should be an anagram of "a", so all paths should be "a", so the answer is 1 ⋅ 1 = 1.

In the first example after the third query, you have two paths with strings "a" and "b", but these strings are not anagrams, so the answer is "Fou".

In the first example after the fourth query, you know that all paths should be "b", so the answer is 1 ⋅ 2 = 2.

In the second example after the first query, you know that f('a') = 2 and f(c) = 1 for all other characters, so the answer is 1 ⋅ (2 + 3 + … + 26) + 2 = 352.

In the second example after the second query, you know that each path should contain one 'a' and one 'b', so the answer is 1 ⋅ 1 + 1 ⋅ 2 = 3.
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5e4 + 2;
int head[N], grp_edge[N][30], max1[N][30], grp[N], level[N], okfine = 0, sum[N],
                                                             dem = 0;
char edge[N];
bool cac = true;
vector<pair<int, char> > adj[N];
vector<int> adj_grp[N];
stack<pair<int, char> > lis;
void dfs(int x) {
  int i = 0, j;
  if (adj[x].size() == 0) {
    if (!okfine) {
      okfine = level[x];
    }
    if (okfine != level[x]) {
      cac = false;
    }
    while (lis.size()) {
      i = lis.top().first;
      if (lis.top().second != '?') {
        grp_edge[x][(int)(lis.top().second - 'a' + 1)]++;
      }
      grp[i] = x;
      lis.pop();
    }
    if (i) {
      adj_grp[head[i]].push_back(x);
      head[x] = head[i];
    }
  }
  if (adj[x].size() == 1) {
    level[adj[x][0].first] = level[x] + 1;
    lis.push({adj[x][0].first, edge[adj[x][0].first]});
    dfs(adj[x][0].first);
  }
  if (adj[x].size() == 2) {
    while (lis.size()) {
      i = lis.top().first;
      if (lis.top().second != '?') {
        grp_edge[x][(int)(lis.top().second - 'a' + 1)]++;
      }
      grp[i] = x;
      lis.pop();
    }
    if (i) {
      adj_grp[head[i]].push_back(x);
      head[x] = head[i];
    }
    level[adj[x][0].first] = level[x] + 1;
    lis.push({adj[x][0].first, edge[adj[x][0].first]});
    dfs(adj[x][0].first);
    level[adj[x][1].first] = level[x] + 1;
    lis.push({adj[x][1].first, edge[adj[x][1].first]});
    dfs(adj[x][1].first);
  }
}
void dfs1(int x) {
  int i, j;
  for (i = 0; i < adj_grp[x].size(); i++) {
    dfs1(adj_grp[x][i]);
    for (j = 1; j <= 26; j++) {
      max1[x][j] =
          max(max1[x][j], max1[adj_grp[x][i]][j] + grp_edge[adj_grp[x][i]][j]);
    }
  }
  for (j = 1; j <= 26; j++) {
    sum[x] += max1[x][j];
  }
  if (sum[x] > okfine - level[x]) {
    dem++;
  }
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, i, j, k, l, q, ans, ans1;
  char x, x1;
  cin >> n >> q;
  for (i = 2; i <= n; i++) {
    cin >> head[i] >> edge[i];
    adj[head[i]].push_back({i, edge[i]});
  }
  dfs(1);
  dfs1(1);
  head[1] = 0;
  for (i = 1; i <= q; i++) {
    if (!cac) {
      cout << "Fou\n";
      continue;
    }
    cin >> j >> x;
    x1 = edge[j];
    if (edge[j] != '?') {
      grp_edge[grp[j]][(int)(edge[j] - 'a' + 1)]--;
    }
    edge[j] = x;
    if (edge[j] != '?') {
      grp_edge[grp[j]][(int)(edge[j] - 'a' + 1)]++;
    }
    k = grp[j];
    while (k != 1) {
      if (adj_grp[head[k]].size() == 2) {
        if (sum[head[k]] > okfine - level[head[k]]) {
          if (x1 != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x1 - 'a' + 1)];
            max1[head[k]][(int)(x1 - 'a' + 1)] =
                max(max1[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)],
                    max1[adj_grp[head[k]][1]][(int)(x1 - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][1]][(int)(x1 - 'a' + 1)]);
            sum[head[k]] += max1[head[k]][(int)(x1 - 'a' + 1)];
          }
          if (x != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x - 'a' + 1)];
            max1[head[k]][(int)(x - 'a' + 1)] =
                max(max1[adj_grp[head[k]][0]][(int)(x - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][0]][(int)(x - 'a' + 1)],
                    max1[adj_grp[head[k]][1]][(int)(x - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][1]][(int)(x - 'a' + 1)]);
            sum[head[k]] += max1[head[k]][(int)(x - 'a' + 1)];
          }
          if (sum[head[k]] <= okfine - level[head[k]]) {
            dem--;
          }
        } else {
          if (x1 != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x1 - 'a' + 1)];
            max1[head[k]][(int)(x1 - 'a' + 1)] =
                max(max1[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)],
                    max1[adj_grp[head[k]][1]][(int)(x1 - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][1]][(int)(x1 - 'a' + 1)]);
            sum[head[k]] += max1[head[k]][(int)(x1 - 'a' + 1)];
          }
          if (x != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x - 'a' + 1)];
            max1[head[k]][(int)(x - 'a' + 1)] =
                max(max1[adj_grp[head[k]][0]][(int)(x - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][0]][(int)(x - 'a' + 1)],
                    max1[adj_grp[head[k]][1]][(int)(x - 'a' + 1)] +
                        grp_edge[adj_grp[head[k]][1]][(int)(x - 'a' + 1)]);
            sum[head[k]] += max1[head[k]][(int)(x - 'a' + 1)];
          }
          if (sum[head[k]] > okfine - level[head[k]]) {
            dem++;
          }
        }
      } else {
        if (sum[head[k]] > okfine - level[head[k]]) {
          if (x1 != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x1 - 'a' + 1)];
            max1[head[k]][(int)(x1 - 'a' + 1)] =
                max1[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)] +
                grp_edge[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)];
            sum[head[k]] += max1[head[k]][(int)(x1 - 'a' + 1)];
          }
          if (x != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x - 'a' + 1)];
            max1[head[k]][(int)(x - 'a' + 1)] =
                max1[adj_grp[head[k]][0]][(int)(x - 'a' + 1)] +
                grp_edge[adj_grp[head[k]][0]][(int)(x - 'a' + 1)];
            sum[head[k]] += max1[head[k]][(int)(x - 'a' + 1)];
          }
          if (sum[head[k]] <= okfine - level[head[k]]) {
            dem--;
          }
        } else {
          if (x1 != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x1 - 'a' + 1)];
            max1[head[k]][(int)(x1 - 'a' + 1)] =
                max1[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)] +
                grp_edge[adj_grp[head[k]][0]][(int)(x1 - 'a' + 1)];
            sum[head[k]] += max1[head[k]][(int)(x1 - 'a' + 1)];
          }
          if (x != '?') {
            sum[head[k]] -= max1[head[k]][(int)(x - 'a' + 1)];
            max1[head[k]][(int)(x - 'a' + 1)] =
                max1[adj_grp[head[k]][0]][(int)(x - 'a' + 1)] +
                grp_edge[adj_grp[head[k]][0]][(int)(x - 'a' + 1)];
            sum[head[k]] += max1[head[k]][(int)(x - 'a' + 1)];
          }
          if (sum[head[k]] > okfine - level[head[k]]) {
            dem++;
          }
        }
      }
      k = head[k];
    }
    if (dem) {
      cout << "Fou\n";
    } else {
      ans = 0;
      ans1 = 0;
      for (j = 1; j <= 26; j++) {
        ans += max1[1][j] * j;
        ans1 += max1[1][j];
      }
      cout << "Shi " << ans + (okfine - ans1) * 27 * 13 << endl;
    }
  }
}
