Problem:
Score : 1100 points

Problem Statement

There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.

Provide answers for the Q queries below. The i-th query has the following format:

Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {a,b,...,z} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.

Constraints

1 ≦ N,Q ≦ 100000

1 ≦ |S_i| (1 ≦ i ≦ N)

S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.

The sum of |S_i| is no more than 400000.

Every S_i is unique.

1 ≦ k_i ≦ N (1 ≦ i ≦ Q)

For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of abcd...z.

Input

Inputs are provided from standard inputs in the following form.

N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}

Output

Output Q lines.

On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.

Sample Input 1

5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz

Sample Output 1

1
2
5
4
2

When the literal sequence is a < b, sorting the input strings in lexicographical order yields aa, aaaaaba, aaab, abbaa, abbba. The answers to queries 1, 3, and 5 are thus 1, 5, and 2, respectively.

When the literal sequence is b < a, sorting the input strings in lexicographical order yields abbba, abbaa, aa, aaab, aaaaaba. The answers to queries 2 and 4 are thus 2 and 4, respectively.

Sample Input 2

8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq

Sample Output 2

4
8
2
3
4
7

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

/*************************************************************************

       Author:            palayutm
       Created Time :     Mon 10 Oct 2016 12:13:01 PM CST

       File Name:         e.cc
       Description:       new style, new life

 ************************************************************************/
#include <bits/stdc++.h>

using namespace std;

typedef unsigned long long ull;

const ull base = 1e9+7;

const int B = 640;

int ch[400005][26], cnt = 1;
vector<int> vec[400006];
vector<string> vstr, vv;
vector<vector<ull> > key;
int cl[B+100][B+100];
int idx[100005];
bool tx[256][267];
int hh[400005];

void insert(char* s, int id) {
  int now = 0;
  for (int i = 0; s[i]; i ++) {
    int c = s[i] - 'a';
    if (!ch[now][c]) {
      ch[now][c] = cnt ++;
    }
    now = ch[now][c];
    vec[now].push_back(id);
  }
  hh[now] = id;
}

char s[400005];

int solve(int k, const string& t){
  string& s = vv[k-1];
  for (int i = 0; i < 26; i ++) {
    for (int j = i+1; j < 26; j ++) {
      tx[t[i]][t[j]] = 1;
      tx[t[j]][t[i]] = 0;
    }
  }
  int ans = 0;
  int now = 0;
  for (int i = 0; i < min(B, (int)s.size()); i ++) {
    if (hh[now] >= 0) {
      ans ++;
    }
    for (int j = 0; j < 26; j ++) {
      if (t[j] == s[i]) {
        now = ch[now][s[i]-'a'];
        break;
      }
      int c = t[j]-'a';
      int num = vec[ch[now][c]].size();
      ans += num;
    }
  }
  if (s.size() < B) {
    return ans;
  }
  sort(vec[now].begin(), vec[now].end(), [](const int xx, const int yy){
      int x = idx[xx], y = idx[yy]; 
      if (cl[x][y] == -1) {
      return vstr[x].size() < vstr[y].size();
      } else {
      int id = cl[x][y];
      return tx[ vstr[x][id] ][ vstr[y][id] ];
      }
      ;
      });
  for (auto x : vec[now]) {
    if (x != k-1) {
      ans ++;
    } else {
      break;
    }
  }
  return ans;
}

int main(int argc, const char *argv[])
{
  memset(hh, -1, sizeof(hh));
  int n;
  cin >> n;
  for (int i = 0; i < n; i ++) {
    scanf("%s", s);
    int len = strlen(s);
    insert (s, i);
    vv.push_back(string(s));
    if (len >= B) {
      idx[i] = vstr.size();
      vstr.push_back(string(s));
      key.push_back(vector<ull>());
      key.back().push_back(s[0]);
      for (int j = 1; j < len; j ++) {
        key.back().push_back(key.back().back()*base + s[j]);
      }
    }
  }
  for (int i = 0; i < (int)vstr.size(); i ++) {
    for (int j = i+1; j < (int)vstr.size(); j ++) {
      const string& x = vstr[i], y = vstr[j];
      int low = 0, high = (int)min(x.size(), y.size()) - 1;
      while (low <= high) {
        int mid = (low + high)/2;
        if (key[i][mid] != key[j][mid]) {
          high = mid -1;
        } else {
          low = mid + 1;
        }
      }
      if (low > (int)min(x.size(), y.size()) - 1) {
        cl[i][j] = cl[j][i] = -1;
      } else {
        cl[i][j] = cl[j][i] = low;
      }
    }
  }
  int q;
  cin >> q;
  while (q --) {
    int k;
    string t;
    cin >> k >> t;
    int now = 0;
    cout << solve(k, t) + 1 << endl;
  }
  return 0;
}