#pragma region Macro
#pragma region Basic
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define FORD(i, a, b) for (int i = (a), i##_len = (b); i > i##_len; i--)
#define FORR(t, a) for (auto t : a)
#define ALL(x) (x).begin(), (x).end()  // sortなどの引数を省略したい
#define GET(i, j) get<j>(i)
#define MT(x, ...) make_tuple(x, __VA_ARGS__)
#define SZ(x) ((int)(x).size())
#define ZERO(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define PB push_back
#ifdef _DEBUG
#define PRE_COMMAND             \
    std::cin.rdbuf(in.rdbuf()); \
    cout << fixed << setprecision(15);
#else
#define PRE_COMMAND cout << fixed << setprecision(15);
#endif
const double EPS = 1e-10;
const double PI = acos(-1.0);
template <class T>
auto MAX(T& seq) {
    return *max_element(seq.begin(), seq.end());
}
template <class T>
auto MIN(T& seq) {
    return *min_element(seq.begin(), seq.end());
}
template <class T>
auto SUM(T& seq) {
    T temp{0};
    auto& temp2 = temp[0];
    return accumulate(seq.begin(), seq.end(), temp2);
}
template <class T>
void SORT(T& seq) {
    sort(seq.begin(), seq.end());
}
template <class T, class S>
void SORT(T& seq, S& sort_order) {
    sort(seq.begin(), seq.end(), sort_order);
}
template <class T>
void SORTR(vector<T>& seq) {
    sort(seq.begin(), seq.end(), greater<T>());
}
template <class T>
void CHMAX(T& a, const T& b) {
    if (a < b) { a = b; }
}
template <class T>
void CHMIN(T& a, const T& b) {
    if (b < a) { a = b; }
}
template <class T>
set<T> VECTOR_2_SET(vector<T>& v) {
    set<T> s;
    for (auto ele : v) { s.insert(ele); }
    return s;
}
template <class T>
vector<T> SET_2_VECTOR(set<T>& s) {
    vector<T> v;
    for (auto ele : s) { v.push_back(ele); }
    return v;
}
template <class T, class S, class R>
long long pow(T n_0, S k_0, R mod_0) {
    long long n = n_0;
    long long k = k_0;
    long long mod = mod_0;
    long long now = 1;
    while (true) {
        if (k & 1) { now = now * n % mod; }
        k >>= 1;
        if (k == 0) { return now; }
        n = (n * n) % mod;
    }
}
#pragma endregion Basic
#pragma region overload
template <class T, class S>
void operator+=(vector<T>& l, S& r) {
    for (auto i : r) { l.push_back(i); }
}
template <class T, class S>
void operator+=(set<T>& l, S& r) {
    for (auto i : r) { l.insert(i); }
}
template <class T, class S>
void operator+=(multiset<T>& l, S& r) {
    for (auto i : r) { l.insert(i); }
}
template <class T, class S>
vector<T> operator+(vector<T>& l, S& r) {
    vector<T> l_copy = l;
    for (auto i : r) { l_copy.push_back(i); }
    return l_copy;
}
template <class T>
vector<T> operator+(const vector<T> l, const vector<T>& r) {
    vector<T> l_copy = l;
    for (auto i : r) { l_copy.push_back(i); }
    return l_copy;
}
template <class T, class S>
set<T> operator+(set<T>& l, S& r) {
    set<T> l_copy = l;
    for (auto i : r) { l_copy.insert(i); }
    return l_copy;
}
template <class T>
set<T> operator+(const set<T> l, const set<T>& r) {
    set<T> l_copy = l;
    for (auto i : r) { l_copy.insert(i); }
    return l_copy;
}
template <class T, class S>
multiset<T> operator+(multiset<T>& l, S& r) {
    set<T> l_copy = l;
    for (auto i : r) { l_copy.insert(i); }
    return l_copy;
}
template <class T>
multiset<T> operator+(const multiset<T> l, const set<T>& r) {
    set<T> l_copy = l;
    for (auto i : r) { l_copy.insert(i); }
    return l_copy;
}
string operator+(const string l, const string& r) {
    string str = l;
    str += r;
    return str;
}
string operator*(const string l, const size_t& r) {
    string str = l;
    for (size_t i = 0; i < r; i++) { str += l; }
    return str;
}
#pragma endregion overload
#pragma region Input
template <class Head>
void INPUT(vector<Head>& head);
template <size_t N, class Head>
void INPUT(array<Head, N>& head);
template <class T1>
void INPUT(tuple<T1>& t);
template <class T1, class T2>
void INPUT(tuple<T1, T2>& t);
template <class T1, class T2, class T3>
void INPUT(tuple<T1, T2, T3>& t);
template <class T1, class T2, class T3, class T4>
void INPUT(tuple<T1, T2, T3, T4>& t);
template <class T1, class T2, class T3, class T4, class T5>
void INPUT(tuple<T1, T2, T3, T4, T5>& t);
template <class Head>
void INPUT(Head& head);
template <class Head, class... Tail>
void INPUT(Head& head, Tail&... tail);
//本体
template <class Head>
void INPUT(vector<Head>& head) {
    for (size_t i = 0; i < head.size(); i++) { INPUT(head[i]); }
}
template <size_t N, class Head>
void INPUT(array<Head, N>& head) {
    for (size_t i = 0; i < head.size(); i++) { INPUT(head[i]); }
}
template <class T1>
void INPUT(tuple<T1>& t) {
    cin >> get<0>(t);
}
template <class T1, class T2>
void INPUT(tuple<T1, T2>& t) {
    cin >> get<0>(t) >> get<1>(t);
}
template <class T1, class T2, class T3>
void INPUT(tuple<T1, T2, T3>& t) {
    cin >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <class T1, class T2, class T3, class T4>
void INPUT(tuple<T1, T2, T3, T4>& t) {
    cin >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <class T1, class T2, class T3, class T4, class T5>
void INPUT(tuple<T1, T2, T3, T4, T5>& t) {
    cin >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t) >> get<4>(t);
}
template <class Head>
void INPUT(Head& head) {
    cin >> head;
}
template <class Head, class... Tail>
void INPUT(Head& head, Tail&... tail) {
    INPUT(head);
    INPUT((tail)...);
}
#pragma endregion Input
#pragma region Print
template <class T1>
void PRINT2(tuple<T1> t);
template <class T1, class T2>
void PRINT2(tuple<T1, T2> t);
template <class T1, class T2, class T3>
void PRINT2(tuple<T1, T2, T3> t);
template <class T1, class T2, class T3, class T4>
void PRINT2(tuple<T1, T2, T3, T4> t);
template <class T1, class T2, class T3, class T4, class T5>
void PRINT2(tuple<T1, T2, T3, T4, T5> t);
template <class Head>
void PRINT2(vector<Head> head);
template <class Head>
void PRINT2(vector<vector<Head>> head);
template <size_t N, class Head>
void PRINT2(vector<array<Head, N>> head);
template <class... Head>
void PRINT2(vector<tuple<Head...>> head);
template <size_t N, class Head>
void PRINT2(array<Head, N> head);
template <class Head>
void PRINT2(Head head);
template <class Head, class... Tail>
void PRINT2(Head head, Tail... tail);
template <class Head>
void PRINT(Head head);
template <class... Head>
void PRINT(Head... head);
template <int N, class Head>
void PRINT(Head head);
template <class T1>
void PRINT2(tuple<T1> t) {
    PRINT2(get<0>(t));
}
template <class T1, class T2>
void PRINT2(tuple<T1, T2> t) {
    PRINT2(get<0>(t), get<1>(t));
}
template <class T1, class T2, class T3>
void PRINT2(tuple<T1, T2, T3> t) {
    PRINT2(get<0>(t), get<1>(t), get<2>(t));
}
template <class T1, class T2, class T3, class T4>
void PRINT2(tuple<T1, T2, T3, T4> t) {
    PRINT2(get<0>(t), get<1>(t), get<2>(t), get<3>(t));
}
template <class T1, class T2, class T3, class T4, class T5>
void PRINT2(tuple<T1, T2, T3, T4, T5> t) {
    PRINT2(get<0>(t), get<1>(t), get<2>(t), get<3>(t), get<4>(t));
}
template <class Head>
void PRINT2(vector<Head> head) {
    for (auto i = head.begin(); i != head.end(); i++) {
        PRINT2(*i);
        if (i != head.end() - 1) { cout << " "; }
    }
}
template <class Head>
void PRINT2(vector<vector<Head>> head) {
    for (auto i = head.begin(); i != head.end(); i++) {
        PRINT2(*i);
        if (i != head.end() - 1) { cout << endl; }
    }
}
template <size_t N, class Head>
void PRINT2(vector<array<Head, N>> head) {
    for (auto i = head.begin(); i != head.end(); i++) {
        PRINT2(*i);
        if (i != head.end() - 1) { cout << endl; }
    }
}
template <class... Head>
void PRINT2(vector<tuple<Head...>> head) {
    for (auto i = head.begin(); i != head.end(); i++) {
        PRINT2(*i);
        if (i != head.end() - 1) { cout << endl; }
    }
}
template <size_t N, class Head>
void PRINT2(array<Head, N> head) {
    for (auto i = head.begin(); i != head.end(); i++) {
        PRINT2(*i);
        if (i != head.end() - 1) { cout << " "; }
    }
}
template <class Head>
void PRINT2(Head head) {
    cout << head;
}
template <class Head, class... Tail>
void PRINT2(Head head, Tail... tail) {
    PRINT2(head);
    cout << " ";
    PRINT2((tail)...);
}
template <class Head>
void PRINT(Head head) {
    PRINT2(head);
    cout << endl;
}
template <class... Head>
void PRINT(Head... head) {
    PRINT2((head)...);
    cout << endl;
}
template <int N, class Head>
void PRINT(Head head) {
    PRINT2(head);
    cout << endl;
}
#pragma endregion Print
#pragma endregion Macro

struct SA_IS {
    string str;
    int length;
    vector<int> suffix_array;

    SA_IS(string temp) {
        str = temp;
        length = (int)(str.size());
        vector<char> t(str.begin(), str.end());
        t.push_back('$');
        suffix_array = induced_sort(t);
    }

    template <class T>
    vector<char> categorize(vector<T>& s) {
        int n = (int)s.size();
        vector<char> L_S(n);
        L_S[n - 1] = 'S';
        for (int i = n - 2; i >= 0; i--) {
            if (s[i] < s[i + 1]) {
                L_S[i] = 'S';
            } else if (s[i] > s[i + 1]) {
                L_S[i] = 'L';
            } else {
                L_S[i] = L_S[i + 1];
            }
        }
        for (int i = 1; i < n; i++) {
            if (L_S[i] == 'S' && L_S[i - 1] == 'L') { L_S[i] = 'M'; }
        }
        return L_S;
    }

    template <class T>
    void bucket_sort(vector<T>& s, vector<int>& bucket, vector<char>& cat,
                     map<T, array<int, 3>>& LSM, vector<int>& is_sort) {
        int n = (int)(cat.size());
        int t;
        if ((int)is_sort.size() > 0) {
            // ソートしたMをバケツに突っ込む。そのうち置き換える
            for (int temp : is_sort) {
                bucket[LSM[s[temp]][2]] = temp;
                LSM[s[temp]][2]--;
            }
        } else {
            // M-typeを入れる。
            for (int i = 0; i < n; i++) {
                if (cat[i] == 'M') {
                    bucket[LSM[s[i]][2]] = i;
                    LSM[s[i]][2]--;
                }
            }
        }
        // L-typeを入れる。
        for (int i = 0; i < n; i++) {
            t = bucket[i] - 1;
            if (t >= 0) {
                if (cat[t] == 'L') {
                    bucket[LSM[s[t]][0]] = t;
                    LSM[s[t]][0]++;
                }
            }
        }
        // S-typeを入れる。
        for (int i = n - 1; i >= 0; i--) {
            t = bucket[i] - 1;
            if (t >= 0) {
                if (cat[t] != 'L') {
                    bucket[LSM[s[t]][1]] = t;
                    LSM[s[t]][1]--;
                }
            }
        }
    }

    template <class T>
    vector<int> induced_sort(vector<T>& s) {
        int t, t2, before, after;  // temp変数
        T c;                   // temp変数
        int n = (int)s.size();
        vector<int> bucket(n, -1), bucket_pre(n, -1);
        if (n == 1) {
            bucket = {0};
            return bucket;
        }
        // 出てくる回数を記録
        map<T, int> counter;
        for (int i = 0; i < n; i++) {
            c = s[i];
            if (counter.find(c) == counter.end()) {
                counter[c] = 1;
            } else {
                counter[c]++;
            }
        }
        // バケツに入れる場所を記録するmap
        map<T, array<int, 3>> LSM, LSM_pre;
        int sum_count = 0;
        for (tuple<T, int> temp : counter) {
            tie(c, t) = temp;
            LSM[c][0] = sum_count, sum_count += t;
            LSM[c][1] = sum_count - 1;
            LSM[c][2] = sum_count - 1;
        }
        LSM_pre = LSM;
        // L,S,Mに分類
        vector<char> cat = categorize(s);
        // 一旦バケットソートでMの順序を決定する
        vector<int> M_rec(0);
        map<int, int> M_map;
        bucket_sort(s, bucket_pre, cat, LSM_pre, M_rec);
        M_map[bucket_pre[0]] = 0;
        t = 0;
        before = n - 1;
        for (int i = 1; i < n; i++) {
            if (cat[bucket_pre[i]] != 'M') { continue; }
            after = bucket_pre[i];
            t2 = 0;
            while (true) {
                if (s[before] < s[after + t2]) {
                    t++;
                    break;
                }
                t2++;
                before++;
                if (before == n) {
                    t++;
                    break;
                }
                if (cat[before] == 'M') {
                    if (cat[after + t2] != 'M') { t++; }
                    break;
                }
            }
            M_map[after] = t;
            before = after;
        }
        for (auto temp : M_map) { M_rec.push_back(get<1>(temp)); }
        int m = (int)M_rec.size();
        // Mのリストを作る
        vector<int> M_list;
        for (int i = 0; i < n; i++) {
            if (cat[i] == 'M') { M_list.push_back(i); }
        }
        // Mについて、再帰的にinduced_sortを行う
        vector<int> is_sort(m);
        if (m > 0) {
            vector<int> is = induced_sort(M_rec);
            for (int i = 0; i < m; i++) { is_sort[m - i - 1] = M_list[is[i]]; }
        }
        bucket_sort(s, bucket, cat, LSM, is_sort);
        return bucket;
    }
    // 0→'<', 1→'>', 2→'=='
    int smaller(string& s, int& temp) {
        int t = suffix_array[temp];
        int n = (int)(s.size()), m = length - t, i = 0;
        while (true) {
            if (i == n) { return 2; }
            if (i == m) { return 0; }
            if (s[i] < str[t + i]) {
                return 1;
            } else if (s[i] > str[t + i]) {
                return 0;
            } else {
                i++;
            }
        }
    }
    // 存在するかどうか
    bool find(string& s) {
        int ok = 0, ng = length;
        while (abs(ok - ng) > 1) {
            int mid = (ok + ng) / 2, v = smaller(s, mid);
            if (v == 0) {
                ok = mid;
            } else if (v == 1) {
                ng = mid;
            } else {
                return true;
            }
        }
        if (smaller(s, ok) == 2 || smaller(s, ng) == 2) {
            return true;
        } else {
            return false;
        }
    }
};

int main() {
    PRE_COMMAND
    int n;
    string s, t;
    INPUT(s, n);
    SA_IS sa(s);
    REP(i, n) {
        INPUT(t);
        PRINT(sa.find(t));
    }
}


Measured memory_bytes: 99416