#pragma GCC optimize("O3,unroll-loops")
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdint> 

using namespace std;

// POPRAWKA: MOD musi być ostro większe niż maksymalne możliwe N (3 * 10^16)!
const uint64_t MOD = 40000000000000000ULL; 

// "Gadżet" - w pełni asymetryczna macierz 5x5
int U[5][5] = {
    {1, 0, 0, 0, 0},
    {1, 1, 0, 0, 0},
    {1, 0, 1, 0, 0},
    {1, 1, 1, 1, 0},
    {1, 0, 1, 1, 1}
};

vector<int> Valid_R, Valid_C;

long long C_binom(int n, int k) {
    if (k < 0 || k > n) return 0;
    long long res = 1;
    for (int i = 1; i <= k; ++i) {
        res = res * (n - i + 1) / i;
    }
    return res;
}

uint64_t get_rank(const vector<int>& c) {
    uint64_t r = 0;
    for (int i = 0; i < c.size(); ++i) {
        r += C_binom(c[i], i + 1);
    }
    return r;
}

vector<int> unrank_comb(uint64_t rank, int k) {
    vector<int> res(k);
    for (int i = k; i >= 1; --i) {
        int x = i - 1;
        while (true) {
            long long ways = C_binom(x + 1, i);
            if (ways > rank) break;
            x++;
        }
        res[i - 1] = x;
        rank -= C_binom(x, i);
    }
    return res;
}

void init() {
    vector<int> U_rows = {1, 3, 5, 15, 29};
    vector<int> U_cols = {31, 10, 28, 24, 16};
    
    for (int i = 0; i < 32; ++i) {
        if (find(U_rows.begin(), U_rows.end(), i) == U_rows.end()) Valid_R.push_back(i);
        if (find(U_cols.begin(), U_cols.end(), i) == U_cols.end()) Valid_C.push_back(i);
    }
}

uint64_t Decode(int M[10][10]) {
    uint64_t min_V = UINT64_MAX;
    int req_C[5] = {31, 10, 28, 24, 16};

    for (int c0 = 0; c0 < 10; ++c0) {
        vector<int> cand;
        for (int r = 0; r < 10; ++r) {
            if (M[r][c0] == 1) cand.push_back(r);
        }
        if (cand.size() < 5) continue;

        int m = cand.size();
        for (int i0 = 0; i0 < m; ++i0) {
        for (int i1 = 0; i1 < m; ++i1) { if (i1 == i0) continue;
        for (int i2 = 0; i2 < m; ++i2) { if (i2 == i0 || i2 == i1) continue;
        for (int i3 = 0; i3 < m; ++i3) { if (i3 == i0 || i3 == i1 || i3 == i2) continue;
        for (int i4 = 0; i4 < m; ++i4) { if (i4 == i0 || i4 == i1 || i4 == i2 || i4 == i3) continue;
            
            vector<int> R_U = {cand[i0], cand[i1], cand[i2], cand[i3], cand[i4]};
            vector<int> C_U;
            C_U.push_back(c0);

            auto find_cols = [&](auto& self, int col_idx, int used_cols) -> void {
                if (col_idx == 5) {
                    vector<int> rem_R, rem_C;
                    for (int i = 0; i < 10; ++i) {
                        if (find(R_U.begin(), R_U.end(), i) == R_U.end()) rem_R.push_back(i);
                        if (find(C_U.begin(), C_U.end(), i) == C_U.end()) rem_C.push_back(i);
                    }

                    vector<pair<int, int>> R_IDs;
                    bool ok = true;
                    for (int r : rem_R) {
                        int id = 0;
                        for (int i = 0; i < 5; ++i) id |= (M[r][C_U[i]] << i);
                        if (find(Valid_R.begin(), Valid_R.end(), id) == Valid_R.end()) { ok = false; break; }
                        R_IDs.push_back({id, r});
                    }
                    if (!ok) return;

                    vector<pair<int, int>> C_IDs;
                    for (int c : rem_C) {
                        int id = 0;
                        for (int i = 0; i < 5; ++i) id |= (M[R_U[i]][c] << i);
                        if (find(Valid_C.begin(), Valid_C.end(), id) == Valid_C.end()) { ok = false; break; }
                        C_IDs.push_back({id, c});
                    }
                    if (!ok) return;

                    sort(R_IDs.begin(), R_IDs.end());
                    sort(C_IDs.begin(), C_IDs.end());

                    for (int i = 0; i < 4; ++i) {
                        if (R_IDs[i].first == R_IDs[i + 1].first) { ok = false; break; }
                        if (C_IDs[i].first == C_IDs[i + 1].first) { ok = false; break; }
                    }
                    if (!ok) return;

                    uint64_t D_val = 0;
                    for (int i = 0; i < 5; ++i) {
                        for (int j = 0; j < 5; ++j) {
                            uint64_t b = M[R_IDs[i].second][C_IDs[j].second];
                            D_val |= (b << (i * 5 + j));
                        }
                    }

                    vector<int> r_idx_arr(5), c_idx_arr(5);
                    for (int i = 0; i < 5; ++i) {
                        r_idx_arr[i] = distance(Valid_R.begin(), find(Valid_R.begin(), Valid_R.end(), R_IDs[i].first));
                        c_idx_arr[i] = distance(Valid_C.begin(), find(Valid_C.begin(), Valid_C.end(), C_IDs[i].first));
                    }

                    uint64_t R_idx = get_rank(r_idx_arr);
                    uint64_t C_idx = get_rank(c_idx_arr);

                    uint64_t V = R_idx * 80730ULL * 33554432ULL + C_idx * 33554432ULL + D_val;
                    min_V = min(min_V, V);
                    return;
                }

                for (int c = 0; c < 10; ++c) {
                    if (!(used_cols & (1 << c))) {
                        int pat = 0;
                        for (int i = 0; i < 5; ++i) pat |= (M[R_U[i]][c] << i);
                        if (pat == req_C[col_idx]) {
                            C_U.push_back(c);
                            self(self, col_idx + 1, used_cols | (1 << c));
                            C_U.pop_back();
                        }
                    }
                }
            };
            find_cols(find_cols, 1, (1 << c0));
        }}}}}
    }
    return min_V;
}

void Encode(uint64_t N) {
    int M[10][10];
    for (uint64_t k = 0;; ++k) {
        uint64_t V = N + k * MOD;
        uint64_t D_val = V % 33554432ULL; V /= 33554432ULL;
        uint64_t C_idx = V % 80730ULL; V /= 80730ULL;
        uint64_t R_idx = V;

        vector<int> r_arr = unrank_comb(R_idx, 5);
        vector<int> c_arr = unrank_comb(C_idx, 5);

        for (int i = 0; i < 10; ++i)
            for (int j = 0; j < 10; ++j)
                M[i][j] = 0;

        for (int i = 0; i < 5; ++i)
            for (int j = 0; j < 5; ++j)
                M[i][j] = U[i][j];

        for (int i = 0; i < 5; ++i) {
            int val = Valid_R[r_arr[i]];
            for (int j = 0; j < 5; ++j) M[5 + i][j] = (val >> j) & 1;
        }

        for (int j = 0; j < 5; ++j) {
            int val = Valid_C[c_arr[j]];
            for (int i = 0; i < 5; ++i) M[i][5 + j] = (val >> i) & 1;
        }

        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 5; ++j) {
                M[5 + i][5 + j] = (D_val >> (i * 5 + j)) & 1;
            }
        }

        if (Decode(M) == N + k * MOD) {
            for (int i = 0; i < 10; ++i) {
                for (int j = 0; j < 10; ++j) {
                    cout << M[i][j];
                }
                cout << "\n";
            }
            cout.flush();
            return;
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    init();

    string who;
    if (!(cin >> who)) return 0;

    uint64_t N_max, T;
    cin >> N_max >> T;

    for (int t = 0; t < T; ++t) {
        if (who == "Algosia") {
            uint64_t N;
            cin >> N;
            Encode(N);
        } else {
            int M[10][10];
            for (int i = 0; i < 10; ++i) {
                string row;
                cin >> row;
                for (int j = 0; j < 10; ++j) {
                    M[i][j] = row[j] - '0';
                }
            }
            uint64_t decoded_N = Decode(M) % MOD;
            cout << decoded_N << "\n";
            cout.flush();
        }
    }
    return 0;
}