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: Wrong Answer)

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <vector>
#include <string>
#include <iostream>
#include <cassert>

using namespace std;

#define rank RANK

const int N = 1e5 + 7;
const int LEN = 4e5 + 7;
const int C = 26;
const int LIMIT = 500;

string s[N];
int n;
char buffer[LEN];

struct Node {
	int id, cnt;
	Node* child[C];
	vector<int> ids;
	Node(int id = -1) : id(id) {
		cnt = 0;
		for (int i = 0; i < C; i++) {
			child[i] = NULL;
		}
	}
};

Node pool[LEN << 2];
Node* root;
int rank[C], sa[C], total = 0;
int lcp[1000][1000], num[N];

void insert(string s, int id) {
	Node *tmp = root;
	for (int i = 0; i < s.size(); i++) {
		int idx = s[i] - 'a';
		tmp->cnt++;
		tmp->ids.push_back(id);
		if (tmp->child[idx] == NULL) {
			tmp->child[idx] = new(pool + total++) Node();
		}
		tmp = tmp->child[idx];
	}
	tmp->id = id;
	tmp->ids.push_back(id);
	tmp->cnt++;
}

vector<int> big;

int solve(int k) {
	int ret = 0;
	Node *tmp = root;
	for (int i = 0; i < LIMIT; i++) {
		if (i == s[k].size()) {
			return ret;
		}
		int idx = s[k][i] - 'a';
		ret += (tmp->id != -1);
		assert(tmp->child[idx] != NULL);
		for (int j = 0; j < rank[idx]; j++) {
			int c = sa[j];
			if (tmp->child[c] == NULL) continue;
			ret += tmp->child[c]->cnt;
		}
		tmp = tmp->child[idx];
	}
	k = num[k];
	for (auto id : tmp->ids) {
		if (id == k) continue;
		int i = num[id];
		int p = lcp[i][k];
		if (p >= min(s[k].size(), s[i].size())) {
			ret += s[i].size() < s[k].size();
		} else {
			ret += (rank[s[i][p] - 'a'] < rank[s[k][p] - 'a']);
		}
	}
	return ret;
}

int main() {
	root = new Node();
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%s", buffer);
		s[i] = buffer;
		insert(s[i], i);
		if (s[i].size() >= LIMIT) {
			num[i] = big.size();
			big.push_back(i);
		}
	}
	for (int i = 0; i < big.size(); i++) {
		int a = big[i];
		for (int j = 0; j < i; j++) {
			int b = big[j], k = 0;
			for (; k < s[a].size() && k < s[b].size() && s[a][k] == s[b][k]; k++) {}
			lcp[i][j] = lcp[j][i] = k;
		}
	}
	int q;
	scanf("%d", &q);
	for (int i = 0; i < q; i++) {
		int k;
		scanf("%d %s", &k, buffer);
		for (int j = 0; j < C; j++) {
			rank[buffer[j] - 'a'] = j;
			sa[j] = buffer[j] - 'a';
		}
		printf("%d\n", solve(--k) + 1);
	}
	return 0;
}