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: Memory Limit Exceeded)

#include <bits/stdc++.h>
#define FOR(i,a,b) for(ut i=(a);i<(ut)(b);i++)
#define REP(i,b) FOR(i,0,b)
#define ALL(c) c.begin(),c.end()
#define PB push_back
#define cat //cout << __LINE__ << endl;
using namespace std;
typedef long long LL;
typedef double ld;
typedef int ut;
typedef complex<int> cli;
typedef vector<ut> VI;
typedef pair<ut,ut> pr;
typedef pair<ut,pr> ppr;
typedef vector<pr> Vpr;
typedef vector<ppr> Vppr;
typedef priority_queue<pr,Vpr> PQ;
const int SIZE=5+1e5;
const int alpha='z'-'a'+1;
int nums[SIZE][alpha][alpha];
int smaller[SIZE];
string s[SIZE];

struct Trie{
	Trie* next[alpha];
	bool isEnd;
	int size,tall;
	void init(){
		size=0;
		isEnd=false;
	}
	Trie():tall(0){init();}
	Trie(int x):tall(x){init();}
	Trie* nextNode(int target){
		if(!next[target]) next[target] = new Trie(tall+1);
		return next[target];
	}
	Trie* nextNode(string s){
		if(s.size()==tall) return NULL;
		return nextNode(s[tall]-'a');
	}
};
bool find(string s,Trie* now){		
	while(now->nextNode(s)){
		now=now->nextNode(s);	
	}
	return now->isEnd;	
}
void add(string s,Trie* root){
	Trie* now=root;
	while(now->nextNode(s)){
		now->size++;
		now=now->nextNode(s);	
	}
	now->isEnd=true;
	now->size++;
}
Trie root;
//Trie nodes[SIZE*10];
int nextnode=1;
void analys(int x){
	Trie* now= &root;
	REP(i,s[x].size()){
		if(now->isEnd) smaller[x]++;
		FOR(j,'a','z'+1){
			if(s[x][i]==j) continue;
			nums[x][j-'a'][s[x][i]-'a']+=now->nextNode(j-'a')->size;
		}
		now=now->nextNode(s[x]);
	}
}
bool isFaster(string p,char a,char b){
	REP(i,p.size()){
		if(p[i]==a) return true;
		if(p[i]==b) return false;
	}
}
int solve(int x,string p){
	int ans=0;
	REP(i,alpha) REP(j,i){
		ans+=nums[x][p[j]-'a'][p[i]-'a'];
		//if(nums[x][i][j])cout << x <<" " <<  char(i+'a') <<" " << char(j+'a') << " " << nums[x][i][j] << endl; 
	}
	return ans+smaller[x];
}
int main(){
	int N;
	cin.tie(0);
	cin >> N;
	//REP(i,SIZE*10) nodes[i].init();
	REP(i,N){
		cin >> s[i];
		add(s[i], &root);
	}
	REP(i,N){
		analys(i);
	}
	int Q,k;
	cin >> Q;
	string p;
	REP(i,Q){
		cin >> k >> p;
		cout << solve(k-1,p)+1 << endl;
	}
	return 0;
}