#include <fstream>
#include <vector>
#include <queue>

using namespace std;

ifstream fin("ahocorasick.in");
ofstream fout("ahocorasick.out");

struct trie{

    trie *f[26];
    vector<trie *> v;
    int solution;
    trie *back;

    trie(){
        solution = 0;
        for(int i = 0; i < 26; i ++)
        {
            f[i] = 0;
        }
        v.clear();
        back = 0;
    }
};

trie *r = new trie();
char A[1000010], s[10010];
trie *w[101], *nod, *aux;
queue<trie *> Q;
int N;

trie *trie_insert(trie *r, char *S)
{
    if(*S == 0)
    {
        return r;
    }

    if(r -> f[*s - 'a'] == NULL)
    {
        r -> f[*s - 'a'] = new trie;
    }
    return trie_insert(r -> f[*s - 'a'], S + 1);
}

void dfs(trie *nod)
{
    for(int i = 0; i < nod -> v.size(); i ++ )
    {
        dfs(nod -> v[i]);
        nod -> solution += nod -> v[i] -> solution;
    }
}

int main()
{
    fin >> A;
    fin >> N;

    for(int i = 1; i <= N; i ++)
    {
        fin >> s;
        w[i] = trie_insert(r, s);
    }

    Q.push(r);

    while(!Q.empty())
    {
        nod = Q.front();
        Q.pop();

        for(int i = 0; i < 26; i ++)
        {
            if(nod -> f[i])
            {
                aux = nod -> back;

                while(aux && aux -> f[i] == NULL)
                {
                    aux = nod -> back;
                }
                if(!aux)
                {
                    nod -> f[i] -> back = r;
                }
                else
                {
                    nod -> f[i] -> back = aux -> f[i];
                }

                nod -> f[i] -> back -> v.push_back(nod -> f[i]);

                Q.push(nod -> f[i]);
            }
        }
    }

    aux = r;

    for(int i = 0; i < A[i] != 0; i ++)
    {
        while(aux != r && aux -> f[A[i] - 'a'] == NULL)
        {
            aux = aux -> back;
        }
        if(aux -> f[A[i] - 'a'])
        {
            aux = aux -> f[A[i] - 'a'];
        }
        aux -> solution ++;
    }

    dfs(r);

    for(int i = 1; i <= N; i ++)
    {
        fout << w[i] -> solution << '\n';
    }

    return 0;
}