import re

no_strings = int(input())
strings = []
no_q = 0
queries = []

for _ in range(no_strings):
    strings.append(input())

no_q = int(input())
for _ in range(no_q):
    queries.append(re.compile(r'^'+input()+'$'))

for pattern in queries:
    found = 0
    for s in strings:
        found += len(pattern.findall(s))
    print(found)

from collections import Counter, defaultdict

cnt = Counter([input().strip() for _ in range(int(input().strip()))]) 

for _ in range(int(input().strip())):
    print(cnt[input().strip()])

s = [input() for _ in range(int(input()))] 
for _ in range(int(input())):
    print(s.count(input()))

Stream.generate(sc::next)
    .limit(sc.nextInt())

.collect(groupingBy(identity(), counting()))

.map(query -> counterMap.getOrDefault(query, 0L))

.forEach(System.out::println)

using System;
using System.Collections.Generic;
using System.IO;
class Solution {
    static void Main(String[] args) {
        int numStrings = Int32.Parse(Console.ReadLine());

        var strings = new SparseArray<string, char>();

        for(int i = 0; i < numStrings; i++)
            strings.Add(Console.ReadLine());

        int numQueries = Int32.Parse(Console.ReadLine());

        for(int i = 0; i < numQueries; i++)
        {
            string query = Console.ReadLine();
            Console.WriteLine(strings.Count(query));
        }
    }
}

class SparseArrayNode<T>
{
    private T _item;
    private LinkedList<SparseArrayNode<T>> _list = new LinkedList<SparseArrayNode<T>>();

    public int Count { get; set; } = 0;

    public SparseArrayNode() { }

    public SparseArrayNode(T item)
    {
        _item = item;
    }

    public SparseArrayNode<T> AddChild(T item)
    {
        var sparseArrayNode = _list.AddLast(new SparseArrayNode<T>(item));
        return sparseArrayNode.Value;
    }

    public SparseArrayNode<T> Find(T item)
    {
        var currentNode = _list.First;

        while(currentNode != null)
        {
            if(currentNode.Value._item.Equals(item))
                return currentNode.Value;

            currentNode = currentNode.Next;
        }

        return null;
    }
}

class SparseArray<TCollection, TItem> where TCollection : IEnumerable<TItem>
{
    SparseArrayNode<TItem> _root = new SparseArrayNode<TItem>();

    public void Add(TCollection value)
    {
        var current = _root;

        foreach(var item in value)
        {
            var node = current.Find(item);

            if(node == null)
                node = current.AddChild(item);

            current = node;
        }

        current.Count++;
    }

    public SparseArrayNode<TItem> Find(TCollection value)
    {
        var current = _root;

        foreach(var item in value)
        {
            current = current.Find(item);

            if(current == null)
                break;
        }

        return current;
    }

    public int Count(TCollection value)
    {
        var node = Find(value);
        return node != null ? node.Count : 0;
    }
}

using System;
using System.Collections.Generic;
using System.IO;
class Solution {
    static void Main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution */
        int strCount = int.Parse(Console.In.ReadLine());
        for (int i = 0; i < strCount; i++)
        {
            string str = Console.In.ReadLine();
            AddWord(str);
        }
        int queryCount = int.Parse(Console.In.ReadLine());
        for (int i = 0; i < queryCount; i++)
        {
            string str = Console.In.ReadLine();
            actual_WordCount(str);
        }        
    }
    static WordNode StartWordNode = null;
    static WordNode LastWordNode = null;
    public static void AddWord(string word)
    {
        //Every new word add new word node             
        if (StartWordNode == null)
            LastWordNode = StartWordNode = new WordNode();
        else
            LastWordNode = LastWordNode.NextWordNode = new WordNode();
        CharacterNode currentCharacter = null;
        for (int i = 0; i < word.Length; i++)
        {
            if (currentCharacter == null)
                currentCharacter = LastWordNode.Character = new CharacterNode();
            else
                currentCharacter = currentCharacter.NextCharacterNode = new CharacterNode();
            currentCharacter.Char = word[i];
            currentCharacter.Position = i;
        }
    }    
    private static void actual_WordCount(string word)
        {
            int count = 0;
            WordNode currentWord = StartWordNode;
            while (currentWord != null)
            {
                CharacterNode currentCharNode = currentWord.Character;
                bool allCharsFound = true;
                for (int i = 0; i < word.Length; i++)
                {
                    if (currentCharNode.Char != word[i] || currentCharNode.Position != i || (i == word.Length - 1 && currentCharNode.NextCharacterNode != null))
                    {
                        allCharsFound = false;
                        break;
                    }
                    currentCharNode = currentCharNode.NextCharacterNode;
                }
                if (allCharsFound)
                    count++;
                currentWord = currentWord.NextWordNode;
            }
            Console.WriteLine(count);
        }
        public static void countWords()
        {
            int strCount = int.Parse(Console.In.ReadLine());
            for (int i = 0; i < strCount; i++)
            {
                string str = Console.In.ReadLine();
                AddWord(str);
            }
            int queryCount = int.Parse(Console.In.ReadLine());
            for (int i = 0; i < queryCount; i++)
            {
                string str = Console.In.ReadLine();
                actual_WordCount(str);
            }
        }    
    
}
public class CharacterNode
{
    public char Char { get; set; }
    public int Position { get; set; }
    public CharacterNode NextCharacterNode { get; set; }
}

public class WordNode
{
    public int WordCount { get; set; }
    public CharacterNode Character { get; set; }
    public WordNode NextWordNode { get; set; }
}