#include <bits/stdc++.h>
using namespace std;
const int MAX = 26;
int encode(char c) {
  return 0 + c - 'a';
  assert(false && "invalid string");
}
struct Node {
  int nxt[MAX + 1];
  int exist;
  vector<int> accept;
  Node() : exist(0) { memset(nxt, -1, sizeof(nxt)); }
};
class Trie {
 private:
  void updateDirect(int node, int id) {
    ac.emplace_back(node);
    nodes[node].accept.emplace_back(id);
  }
  void updateChild(int node, int child, int id) { ++nodes[node].exist; }
  void add(const string &str, int str_index, int node_index, int id) {
    if (str_index == str.size())
      updateDirect(node_index, id);
    else {
      const int c = encode(str[str_index]);
      if (nodes[node_index].nxt[c] == -1) {
        nodes[node_index].nxt[c] = (int)nodes.size();
        nodes.emplace_back(Node());
      }
      add(str, str_index + 1, nodes[node_index].nxt[c], id);
      updateChild(node_index, nodes[node_index].nxt[c], id);
    }
  }
  void add(const string &str, int id) { add(str, 0, 0, id); }

 public:
  vector<Node> nodes;
  vector<int> ac;
  int root;
  Trie() : root(0) { nodes.emplace_back(Node()); }
  void add(const string &str) { add(str, nodes[0].exist); }
  int size() { return (nodes[0].exist); }
  int nodesize() { return ((int)nodes.size()); }
};
class AhoCorasick : public Trie {
 public:
  static const int FAIL = MAX;
  vector<int> correct;
  AhoCorasick() : Trie() {}
  void build() {
    correct.resize(nodes.size());
    for (int i = 0; i < (nodes.size()); i++)
      correct[i] = (int)nodes[i].accept.size();
    queue<int> que;
    for (int i = 0; i < (MAX + 1); i++) {
      if (~nodes[0].nxt[i]) {
        nodes[nodes[0].nxt[i]].nxt[FAIL] = 0;
        que.emplace(nodes[0].nxt[i]);
      } else
        nodes[0].nxt[i] = 0;
    }
    while (!que.empty()) {
      Node now = nodes[que.front()];
      correct[que.front()] += correct[now.nxt[FAIL]];
      que.pop();
      for (int i = 0; i < (MAX); i++) {
        if (now.nxt[i] == -1) continue;
        int fail = now.nxt[FAIL];
        while (nodes[fail].nxt[i] == -1) {
          fail = nodes[fail].nxt[FAIL];
        }
        nodes[now.nxt[i]].nxt[FAIL] = nodes[fail].nxt[i];
        auto &u = nodes[now.nxt[i]].accept;
        auto &v = nodes[nodes[fail].nxt[i]].accept;
        vector<int> accept;
        set_union((u).begin(), (u).end(), (v).begin(), (v).end(),
                  back_inserter(accept));
        u = accept;
        que.emplace(now.nxt[i]);
      }
    }
  }
  int match(const string &str, vector<int> &result, int now = 0) {
    result.assign(size(), 0);
    int count = 0;
    for (auto &c : str) {
      while (nodes[now].nxt[encode(c)] == -1) now = nodes[now].nxt[FAIL];
      now = nodes[now].nxt[encode(c)];
      count += correct[now];
      for (auto &v : nodes[now].accept) result[v]++;
    }
    return count;
  }
  int next(int now, char c) {
    while (nodes[now].nxt[encode(c)] == -1) now = nodes[now].nxt[FAIL];
    return nodes[now].nxt[encode(c)];
  }
};
int main() {
  string s;
  int n;
  cin >> s >> n;
  AhoCorasick aho;
  for (int i = 0; i < (n); i++) {
    string a;
    cin >> a;
    aho.add(a);
  }
  vector<int> res;
  aho.build();
  aho.match(s, res);
  for (auto i : res) cout << (i == 0 ? 0 : 1) << endl;
}
