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

int main() {
    // Tạo mảng lưu 20 số giai thừa đầu tiên
    vector<long long> f(21);
    f[0] = 1;
    for (int i = 1; i <= 20; ++i) {
        f[i] = f[i-1] * i;
    }

    int M;
    if (cin >> M) {
        while (M--) {
            long long N;
            cin >> N;
            bool found = false;
            // Thử tất cả các tổ hợp 3 số giai thừa phân biệt
            for (int i = 1; i <= 20 && !found; ++i) {
                for (int j = i + 1; j <= 20 && !found; ++j) {
                    for (int k = j + 1; k <= 20 && !found; ++k) {
                        if (f[i] + f[j] + f[k] == N) {
                            found = true;
                        }
                    }
                }
            }
            cout << (found ? 1 : 0) << endl;
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    freopen("fac.inp", "r", stdin);
    freopen("fac.out", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    // Precompute factorials
    vector<long long> f;
    long long cur = 1;
    for (int i = 1; ; ++i) {
        cur *= i;
        // Giả định 20! là số giai thừa cuối cùng vừa phải
        // Hoặc break khi cur vượt quá giá trị lớn nhất của N (10^18)
        if (cur > 1000000000000000000ULL) break; 
        f.push_back(cur);
    }

    int M;
    if (cin >> M) {
        while (M--) {
            long long a;
            cin >> a;
            bool ok = false;
            int n = f.size();

            // Optimization: Kiểm tra nhanh nếu N quá nhỏ
            if (a < f[0] + f[1] + f[2]) {
                cout << 0 << "\n";
                continue;
            }

            for (int i = 0; i < n && !ok; ++i) {
                for (int j = i + 1; j < n && !ok; ++j) {
                    for (int k = j + 1; k < n && !ok; ++k) {
                        // Sử dụng unsigned __int128 hoặc kiểm tra tràn số nếu cần
                        long long s = f[i] + f[j] + f[k];
                        if (s == a) ok = true;
                    }
                }
            }
            cout << (ok ? 1 : 0) << "\n";
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

int main() {
    freopen("fac.inp", "r", stdin);
    freopen("fac.out", "w", stdout);

    // Precompute factorials
    vector<long long> f;
    long long cur = 1;
    for (int i = 1; i <= 20; ++i) {
        cur *= i;
        f.push_back(cur);
    }

    int M;
    if (cin >> M) {
        while (M--) {
            long long N;
            cin >> N;
            bool found = false;

            // Duyệt i, j trước, sau đó kiểm tra N - f[i] - f[j] có trong tập số giai thừa còn lại không
            // Để đảm bảo phân biệt, ta cần đảm bảo k > j

            for (int i = 0; i < f.size() && !found; ++i) {
                for (int j = i + 1; j < f.size() && !found; ++j) {
                    long long remainder = N - f[i] - f[j];
                    if (remainder <= 0) continue;

                    // Kiểm tra remainder có phải là số giai thừa phân biệt với f[i], f[j] (tức là f[k] với k > j)
                    // Do mảng f đã được sắp xếp tăng dần, ta chỉ cần tìm phần tử remainder trong mảng 
                    // từ vị trí j+1 trở đi.

                    // Hoặc đơn giản hơn, dùng set chứa tất cả các số giai thừa,
                    // nhưng phải chú ý đến điều kiện phân biệt.
                    // Cách này không tối ưu bằng 3 vòng lặp vì overhead của Set.

                    // Tối ưu nhất: Dùng 2 vòng lặp + binary search
                    // Hoặc 3 vòng lặp (vì mảng quá nhỏ).
                }
            }

            // Logic thực tế từ các solution là 3 vòng lặp là đủ nhanh.
            cout << (found ? 1 : 0) << "\n";
        }
    }
    return 0;
}