#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;

#define elif else if
#define debug_(x) cerr << (x)
#define print_(x) cout << (x)
#define all(a) a.begin(), a.end()
#define finish(x) print(x); return
#define prints(x) cout << (x) << " "
#define print(x) cout << (x) << endl
#define debug(x) cerr << (x) << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define range(i, n, m) for (int i = n; i < m; i++)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; i--)
#define srange(i, n, m, w) for (int i = n; i < m; i += w)
#define rrange(i, n, m) for (int i = (m) - 1; i >= n; i--)
#define rsrange(i, n, m, w) for (int i = (m) - 1; i >= n; i -= w)
#define subset(i, j) for(int i = j; i >= 0; i = i ? (i - 1) & j : -1)
#define Seg segtree<S, op, e>
#define LazySeg lazy_segtree<S, op, e, F, mapping, composition, id>

using us = unsigned;
using str = string;
using ll = long long;
template <typename T>
using vec = vector<T>;
template <typename S, typename T>
using uomap = unordered_map<S, T>;
template <typename S>
using pq = priority_queue<S>;
template <typename S>
using inv_pq = priority_queue<S, vec<S>, greater<S>>;

const ll mod = 998244353;
using mint = modint998244353;
istream& operator>>(istream& is, mint& v) {
    ll x; cin >> x;
    v = x;
    return is;
}
ostream& operator<<(ostream& os, mint& v) {
    os << v.val();
    return os;
}
template <typename T>
istream& operator>>(istream& is, vec<T>& v) {
    for(T& i: v) is >> i;
    return is;
}
template <typename T>
ostream& operator<<(ostream& os, vec<T>& v) {
    for(T i: v) os << i << " ";
    return os;
}

void Yes(bool f) { print(f ? "Yes" : "No"); }
void No(bool f) { print(f ? "No" : "Yes"); }

template <typename S>
S lcm(S a, S b) { return (a / gcd(a, b)) * b; }

template <typename T>
int len(const T& x) { return (int)(x.size()); }

template <typename T>
vec<T> settify(vec<T> x) {
    sort(all(x));
    x.erase(unique(all(x)), x.end());
    return x;
}

template <int B, typename T>
bool sort_Mo(tuple<int, int, T> a, tuple<int, int, T> b) {
    int a1 = get<0>(a) / B, b1 = get<0>(b) / B;
    int a2 = get<1>(a), b2 = get<1>(b);
    if (a1 != b1) return (a1 < b1);
    if (a1 & 1) return (a2 < b2);
    return (a2 > b2);
}

ll modpow(ll a, ll x, ll p) {
    if (x == 0) return 1;
    a %= p;
    if (x == 1) return a;
    ll res = modpow(a, x / 2, p);
    res = (res * res) % p;
    if (x & 1) res = (res * a) % p;
    return res;
}

template <typename T>
bool chmax(T &a, const T &b) {
    if (a < b) { a = b; return true; }
    return false;
}
template <typename T>
bool chmin(T &a, const T &b) {
    if (a > b) { a = b; return true; }
    return false;
}

struct SPF {
    int MX;
    vec<int> spf;
    SPF (int n) : MX(n) {
        spf.resize(n + 1);
        rep(i, n) spf[i] = i;
        range(i, 2, n + 1) if (spf[i] == i) {
            srange(j, 2 * i, n + 1, i) if (spf[j] == j) spf[j] = i;
        }
    }
    const int operator[](int i) { return spf[i]; }
};

struct Poly {
    vec<ll> f;
    Poly(int n) : f(n, 0) {};
    Poly(vec<ll> f_) : f(f_) {}; 

    int size() const { return f.size(); }
    ll operator[](int idx) const {
        if (idx < 0 || idx >= f.size()) return 0;
        return f[idx];
    }
    ll& operator[](int idx) { 
        if (len(f) <= idx) f.resize(idx + 1); 
        return f[idx];
    }

    Poly& operator=(const Poly& g) { f = g.f; return *this; }
    Poly operator+(const Poly& g) const {
        int siz = max(size(), len(g));
        vec<ll> res(siz);
        rep(i, size()) { res[i] += f[i]; res[i] %= mod; }
        rep(i, len(g)) { res[i] += g[i]; res[i] %= mod;}
        return Poly{res};
    }
    Poly operator*(const Poly& g) const {
        return Poly{convolution(f, g.f)};
    }
    void operator+=(const Poly& g) { *this = *this + g; }
    void operator*=(const Poly& g) { *this = *this * g; }

    Poly pow(ll n, int max = -1) const {
        if (n == 0) return Poly{{1}};
        if (n == 1) return *this;
        Poly res = pow(n / 2 , max);
        res *= res;
        if (n & 1) res *= *this;
        if (max != -1) while(len(res) > max) res.f.pop_back();
        return res;
    }

    void print_all() { print(f); }
};

template <typename T>
T op_add(T a, T b) { return a + b; }   
template <typename T>
T op_prod(T a, T b) { return a * b; }
template <typename T>
T op_min(T a, T b) { return min(a, b); }
template <typename T>
T op_max(T a, T b) { return max(a, b); }

template <typename T, T b>
T cfunc() { return b; }

template <typename T>
T e_add() {
    if constexpr (is_same_v<T, Poly>) return {vec<ll>(0)};
    return 0;
}
template <typename T>
T e_prod() {
    if constexpr (is_same_v<T, Poly>) return {vec<ll>(1,1)};
    return 1;
}
template <typename T>
T e_min() {
    if constexpr (is_same_v<T, int>) return INT_MAX;
    if constexpr (is_same_v<T, ll>) return LLONG_MAX;
    // static_assert(0, "e_min: typename not allowed");
}
template <typename T>
T e_max() {
    if constexpr (is_same_v<T, int>) return INT_MIN;
    if constexpr (is_same_v<T, ll>) return LLONG_MIN;
    // static_assert(0, "e_max: typename not allowed");
}

template <typename T>
using segtree_add = segtree<T, op_add<T>, e_add<T>>;
template <typename T>
using segtree_prod = segtree<T, op_prod<T>, e_prod<T>>;
template <typename T>
using segtree_min = segtree<T, op_min<T>, e_min<T>>;
template <typename T>
using segtree_max = segtree<T, op_max<T>, e_max<T>>;

mint bostan_mori(Poly f, Poly g, ll n) {
    if (n == 0) return ((mint)(f[0]) / (mint)(g[0]));
    Poly g_ = g;
    srange(i, 1, len(g), 2) g_[i] *= -1;
    f *= g_; g *= g_;
    Poly f2(len(f) / 2 + 1), g2(len(g) / 2 + 1);
    rep(i, len(g2)) g2[i] = g[2 * i];
    if (n & 1) rep(i, (len(f) + 1) / 2) f2[i] = f[2 * i + 1];
    else rep(i, (len(f)) / 2) f2[i] = f[2 * i];
    return bostan_mori(f2, g2, n / 2);
}

void slv();

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    #ifdef LOCAL
    int t;
    cin >> t;
    print("==========");
    rep(i, t) {
        debug_("Processing testcase ");
        debug_(i + 1);
        debug("...");
        slv(); print("==========");
    }
    debug("==========================");
    debug("Code execution successful!");
    str s;
    if (cin >> s) debug("Warning: input not finished");
    #else
    slv();
    #endif
    return 0;
}

vec<int> dy = {0, 1, 0, -1};
vec<int> dx = {1, 0, -1, 0};

void slv() {
	int t;cin>>t;
	rep(i,t){
		int n;cin>>n;
		if(n>1)print(0);
		else print(1);
	}
}