output_description: 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.
  
  * * *
input_description: 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}
attempt: import array
  
  R = range
  L = input
  T = [0] * 28
  N = int(L())
  S = []
  U = N * 26**2 * array.array("i", [0])
  V = N * [0]
  Q = int(L())
  for I in R(N):
      S += [[ord(C) - 95 for C in L()]]
      P = 0
      for C in S[I]:
          if T[P + C] == 0:
              T[P + C] = len(T)
              T += [0] * 28
          T[P] += 1
          P = T[P + C]
      T[P] += 1
      T[P + 1] = 1
  while N:
      N -= 1
      P = 0
      for C in S[N]:
          for A in R(26):
              X = T[P + A + 2]
              if (A != C - 2) * X:
                  U[676 * N + 26 * A + C - 2] += T[X]
          V[N] += T[P + 1]
          P = T[P + C]
  while Q:
      K, P = L().split()
      K = int(K) - 1
      P = [ord(C) - 97 for C in P]
      X = 1 + V[K]
      for A in R(26):
          for B in R(A + 1, 26):
              X += U[676 * K + 26 * P[A] + P[B]]
      print(X)
      Q -= 1
  
problem_description: 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}.
samples: [{"input": "5\n    aa\n    abbaa\n    abbba\n    aaab\n    aaaaaba\n    5\n    1 abcdefghijklmnopqrstuvwxyz\n    2 bacdefghijklmnopqrstuvwxyz\n    3 abcdefghijklmnopqrstuvwxyz\n    4 bacdefghijklmnopqrstuvwxyz\n    5 abcdefghijklmnopqrstuvwxyz", "output": "1\n    2\n    5\n    4\n    2\n    \n\nWhen the literal sequence is `a` < `b`, sorting the input strings in\nlexicographical order yields `aa`, `aaaaaba`, `aaab`, `abbaa`, `abbba`. The\nanswers to queries 1, 3, and 5 are thus 1, 5, and 2, respectively.\n\nWhen the literal sequence is `b` < `a`, sorting the input strings in\nlexicographical order yields `abbba`, `abbaa`, `aa`, `aaab`, `aaaaaba`. The\nanswers to queries 2 and 4 are thus 2 and 4, respectively.\n\n* * *"}, {"input": "8\n    abrakatabra\n    abadaba\n    abracadabra\n    atcoder\n    grand\n    contest\n    ababa\n    a\n    6\n    3 abcdefghijklmnopqrstuvwxyz\n    6 qwertyuiopasdfghjklzxcvbnm\n    8 poiuytrewqlkjhgfdsamnbvcxz\n    2 qazwsxedcrfvtgbyhnujmikolp\n    1 plokmijnuhbygvtfcrdxeszwaq\n    4 mnbvcxzasdfghjklpoiuytrewq", "output": "4\n    8\n    2\n    3\n    4\n    7"}]