// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

#define int long long



typedef long long ll;

typedef unsigned long long ull;

typedef unsigned __int128 HASH;

typedef pair<int,int> pii;

typedef pair<ll, ll> pll;

typedef pair<ull, ull> pullull;

typedef pair<ll,int> plli;

typedef pair<double, int> pdbi;

typedef pair<int,pii> pipii;

typedef vector<int> vi;

typedef vector<ll> vll;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<pii> vpii;



#define rep(i,n) for (int i=0;i<(n);i++)

#define rep2(i,a,b) for (int i=(a);i<(b);i++)

#define rrep(i,n) for (int i=(n);i>0;i--)

#define rrep2(i,a,b) for (int i=(a);i>b;i--)

#define pb push_back

#define fi first

#define se second

#define all(a) (a).begin(),(a).end()



const ll mod = 1000000000 + 7;

const ll hmod1 = 999999937;

const ll hmod2 = 1000000000 + 9;

const ll INF = 1<<30;

const int dx4[4] = {1, 0, -1, 0};

const int dy4[4] = {0, 1, 0, -1};

const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};

const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};

const double pi = 3.141592653589793;



struct SuffixArray {

    int n, k;

    string text;

    vector<int> sa;

    vector<int> rank;

    vector<int> lcp;



    SuffixArray (const string &s)

    : text(s), n(s.size()), sa(n + 1), rank(n + 1), lcp(n)

    {}



    bool comp(int i, int j) {

        if (rank[i] != rank[j]) return rank[i] < rank[j];

        int ri = i + k <= n ? rank[i + k] : -1;

        int rj = j + k <= n ? rank[j + k] : -1;

        return ri < rj;

    }



    void construct_sa() {

        for (int i = 0; i <= n; i++) {

            sa[i] = i;

            rank[i] = i < n ? text[i] : -1;

        }



        for (k = 1; k <= n; k *= 2) {

            sort(sa.begin(), sa.end(), [&](const int& i, const int& j) {return comp(i, j);});



            vector<int> tmp(n + 1);

            tmp[sa[0]] = 0;

            for (int i = 1; i <= n; i++) {

                tmp[sa[i]] = tmp[sa[i - 1]] + (comp(sa[i - 1], sa[i]) ? 1 : 0);

            }



            for (int i = 0; i <= n; i++) {

                rank[i] = tmp[i];

            }

        }

    }



    void construct_lcp () {

        int h = 0;

        lcp[0] = 0;

        for (int i = 0; i < n; i++) {

            int j = sa[rank[i] - 1];

            if (h > 0) h--;

            for (; j + h < n && i + h < n; h++) {

                if (text[j + h] != text[i + h]) break;

            }

            lcp[rank[i] - 1] = h;

        }

    }



    inline int low_bd(const string &pt) {

        int l = 0, r = n + 1;

        while (r - l > 1) {

            int m = (r + l) / 2;

            int val = text.compare(sa[m], pt.length(), pt);

            if (val < 0) l = m;

            else r = m;

        }

        return r;

    }



    int up_bd(const string &pt) {

        int l = 1, r = n + 1;

        while (r - l > 1) {

            int m = (r + l) / 2;

            int val = text.compare(sa[m], pt.length(), pt);

            if (val <= 0) l = m;

            else r = m;

        }

        return r;

    }



    bool match(const string &pt) {

        int idx = low_bd(pt);

        if (idx == sa.size()) return false;

        return text.compare(sa[idx], pt.length(), pt) == 0 ? true : false;

    }



    int count(const string &pt) {

        int l_idx = low_bd(pt);

        if (l_idx == sa.size()) return 0;

        if (text.compare(sa[l_idx], pt.length(), pt) != 0) return 0;

        int r_idx = up_bd(pt);

        return r_idx - l_idx;

    }

};



string t;

int q;

string p[10000];



signed main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    cin >> t;

    cin >> q;

    rep(i, q) cin >> p[i];

    SuffixArray suf(t);

    suf.construct_sa();

    rep(i, q) {

        if (suf.match(p[i])) cout << 1 << endl;

        else cout << 0 << endl;

    }

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

#define rep(i,n) for(int i = 0; i < n; i++)

using namespace std;



vector<int> SuffixArray;



vector<int> SA_IS(vector<int> str, int var) {

    if(str.size() == 1) {

        vector<int> ret(1,0);

        return ret;

    }

    str.push_back(0);

    int si = str.size();

    vector<int> st(var, 0), en(var, 0);

    vector<int> SL(si, 0); //s..0, l..1

    vector<int> SA(si, -1);

    vector<int> LMS;

    vector<int> is_LMS(si, -1);

    rep(i,str.size()) en[str[i]]++;

    for(int i = 1; i < var; i++) en[i] += en[i-1];

    for(int i = 1; i < var; i++) st[i] = en[i-1];

    SL[str.size()-1] = 0;

    for(int i = str.size()-2; i >= 0; i--) {

        if(str[i] == str[i+1]) {

            SL[i] = SL[i+1];

            continue;

        }

        if(str[i] > str[i+1]) SL[i] = 1;

        else SL[i] = 0;

    }

    for(int i = 1; i < str.size(); i++) {

        if(SL[i] == 0 && SL[i-1] == 1) {

            SA[--en[str[i]]] = i;

            LMS.push_back(i);

            is_LMS[i] = 1;

        }

    }

    rep(i,var-1) en[i] = st[i+1];

    en[var-1] = str.size();



    rep(i,str.size()) if(SA[i] > 0 && SL[SA[i]-1] == 1) { SA[st[str[SA[i]-1]]++] = SA[i]-1; }

    st[0] = 0;

    for(int i = 1; i < var; i++) st[i] = en[i-1];



    for(int i = 1; i < str.size(); i++) if(SA[i] != -1 && SL[SA[i]] == 0) { SA[i] = -1; }



    for(int i = str.size()-1; i >= 1; i--) if(SA[i] > 0 && SL[SA[i]-1] == 0) { SA[--en[str[SA[i]-1]]] = SA[i]-1; }

    rep(i,var-1) en[i] = st[i+1];

    en[var-1] = str.size();



    int counter = 0;

    vector<int> pre_sa, new_sa;

    rep(i,SA.size()) if(is_LMS[SA[i]] != -1) {

        is_LMS[SA[i]] = ++counter;



        new_sa.clear();

        for(int j = SA[i]; j < SA.size(); j++) {

            new_sa.push_back(str[j]);

            if(j != SA[i] && is_LMS[j] != -1) {

                break;

            }

        }

        if(pre_sa == new_sa) {

            is_LMS[SA[i]] = --counter;

        }

        pre_sa = new_sa;

    }



    vector<int> new_str;

    vector<int> rev((int)LMS.size()+1, 0);

    counter = 0;

    rep(i,is_LMS.size()) {

        if(is_LMS[i] != -1) {

            new_str.push_back(is_LMS[i]);

            rev[counter++] = i;

        }

    }

    vector<int> rec = SA_IS(new_str, new_str.size()+1);



    rep(i,SA.size()) SA[i] = -1;



    for(int i = rec.size()-1; i >= 0; i--) { SA[--en[str[rev[rec[i]]]]] = rev[rec[i]]; }

    rep(i,var-1) en[i] = st[i+1];

    en[var-1] = str.size();



    rep(i,str.size()) if(SA[i] > 0 && SL[SA[i]-1] == 1) { SA[st[str[SA[i]-1]]++] = SA[i]-1; }



    for(int i = 1; i < str.size(); i++) if(SA[i] != -1 && SL[SA[i]] == 0) { SA[i] = -1; }



    for(int i = str.size()-1; i >= 1; i--) if(SA[i] > 0 && SL[SA[i]-1] == 0) { SA[--en[str[SA[i]-1]]] = SA[i]-1; }



    SA.erase(SA.begin());

    return SA;

}



string t;

int q;



bool it_substr(int saidx, const vector<int> &text, const vector<int> &pt) {

  int len = pt.size();

  int n = t.size();

  len = min(len, n - SuffixArray[saidx]);

  int st = SuffixArray[saidx];

  int d = 0;

  rep(i, len) {

    d++;

    if (text[st+i] < pt[i]) return true;

    else if (text[st+i] > pt[i]) return false;

  }

  if (st + d < n) {

    return false;

  }

  else {

    if (d < (int)pt.size()) return true;

    else return false;

  }

}



bool match(const vector<int> &text, const vector<int> &pt) {

    int n = t.size();

    int l = -1, r = n;

    while (r - l > 1) {

        int m = (r + l) / 2;

        if (it_substr(m, text, pt)) l = m;

        else r = m;

    }

    if (r == n) return false;

    //cerr << r << endl;

    int st = SuffixArray[r];

    if (st + (int)pt.size() > n) return false;

    rep(i, pt.size()) {

      if (pt[i] != text[st+i]) return false;

    }

    return true;

}



map<char, int> trans;

int trans_counter = 0;



vector<int> string_to_nums(string& s) {

  rep(i, s.size()) {

    if (trans.find(s[i]) != trans.end()) continue;

    trans[s[i]] = ++trans_counter;

  }

  vector<int> ret;

  rep(i, s.size()) {

    ret.push_back(trans[s[i]]);

  }

  return ret;

}





int main() {

  std::ios::sync_with_stdio(false);

  std::cin.tie(0);

  cin >> t;

  cin >> q;

  vector<int> words = string_to_nums(t);

  SuffixArray = SA_IS(words, 256);

  rep(i, q) {

    string p;

    cin >> p;

    vector<int> pwords = string_to_nums(p);

    if (match(words, pwords)) cout << 1 << endl;

    else cout << 0 << endl;

  }

}




// Fastest known solution for this problem: