#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

class AhoCorasickAutomaton {
  public:
    static const int NIL = -1;
    static const int SIGMA = 26;

    AhoCorasickAutomaton(const vector<string> &words):
      start(0),
      size(1),
      delta(vector< vector<int> >(1, vector<int>(SIGMA, NIL))),
      pi(vector<int>(1, 0)),
      order(vector<int>()),
      signatureCount(int(words.size())),
      signatureIndices(vector< vector<int> >(1, vector<int>())) {
        for (int i = 0; i < int(words.size()); ++i) {
            int x = start;
            for (int j = 0; j < int(words[i].length()); x = delta[x][Encode(words[i][j++])])
                if (delta[x][Encode(words[i][j])] == NIL)
                    delta[x][Encode(words[i][j])] = NewNode();
            signatureIndices[x].push_back(i);
        }
        order.push_back(start);
        for (int i = 0; i < int(order.size()); ++i) {
            int x = order[i];
            for (int symbol = 0; symbol < SIGMA; ++symbol) {
                int p = pi[x];
                for (; p != start && delta[p][symbol] == NIL; p = pi[p]);
                if (delta[p][symbol] != NIL && delta[p][symbol] != delta[x][symbol])
                    p = delta[p][symbol];
                if (delta[x][symbol] == NIL) {
                    delta[x][symbol] = p;
                } else {
                    pi[delta[x][symbol]] = p;
                    order.push_back(delta[x][symbol]);
                }
            }
        }
        reverse(order.begin(), order.end());
    }

    vector<int> GetFrequences(const string &stringToSearch) {
        vector<int> signatureFrequences = vector<int>(signatureCount, 0), vertexFrequences = vector<int>(size, 0);
        for (int x = start, i = 0; i < int(stringToSearch.length()); ++i)
            ++vertexFrequences[x = delta[x][Encode(stringToSearch[i])]];
        for (int i = 0; i + 1 < int(order.size()); ++i)
            vertexFrequences[pi[order[i]]] += vertexFrequences[order[i]];
        for (int x = 0; x < size; ++x)
            for (vector<int>::const_iterator signature = signatureIndices[x].begin(); signature != signatureIndices[x].end(); ++signature)
                signatureFrequences[*signature] += vertexFrequences[x];
        return signatureFrequences;
    }

  private:
    int start, size;
    vector< vector<int> > delta;
    vector<int> pi, order;
    int signatureCount;
    vector< vector<int> > signatureIndices;

    static int Encode(const char symbol) {
        return int(symbol - 'a');
    }

    int NewNode() {
        delta.push_back(vector<int>(SIGMA, NIL));
        pi.push_back(start);
        signatureIndices.push_back(vector<int>());
        return size++;
    }
};

int main() {
    ifstream cin("ahocorasick.in");
    ofstream cout("ahocorasick.out");
    string stringToSearch;
    cin >> stringToSearch;
    int n;
    cin >> n;
    vector<string> patterns = vector<string>(n, "");
    for (int i = 0; i < n; ++i)
        cin >> patterns[i];
    AhoCorasickAutomaton automaton = AhoCorasickAutomaton(patterns);
    vector<int> frequences = automaton.GetFrequences(stringToSearch);
    for (int i = 0; i < n; ++i)
        cout << frequences[i] << "\n";
    cin.close();
    cout.close();
    return 0;
}