#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <cstring>

using namespace std;

// Maksymalna wartość, którą mieścimy w jednym "podejściu" kodowania
const long long POJEMNOSC_MODULO = 30000000000000005LL;

// Tablica do przechowywania symbolu Newtona (kombinacji)
long long dwumian_newtona[35][35];

void przygotuj_tablice_kombinacji() {
    for (int n = 0; n < 35; ++n) {
        dwumian_newtona[n][0] = 1;
        for (int k = 1; k <= n; ++k) {
            dwumian_newtona[n][k] = dwumian_newtona[n - 1][k - 1] + dwumian_newtona[n - 1][k];
        }
    }
}

vector<int> dozwolone_wzorce_wierszy;
vector<int> dozwolone_wzorce_kolumn;
int mapa_wzorcow_wierszy[32];
int mapa_wzorcow_kolumn[32];

void przygotuj_wzorce_identyfikacyjne() {
    memset(mapa_wzorcow_wierszy, -1, sizeof(mapa_wzorcow_wierszy));
    memset(mapa_wzorcow_kolumn, -1, sizeof(mapa_wzorcow_kolumn));

    // Wybieramy wzorce 5-bitowe, które NIE kolidują z naszą "Kotwicą"
    for (int i = 1; i <= 31; ++i) {
        if (i != 16 && i != 24 && i != 28 && i != 30 && i != 31) {
            dozwolone_wzorce_wierszy.push_back(i);
        }
    }
    for (size_t i = 0; i < dozwolone_wzorce_wierszy.size(); ++i) {
        mapa_wzorcow_wierszy[dozwolone_wzorce_wierszy[i]] = i;
    }

    for (int i = 1; i <= 31; ++i) {
        if (i != 1 && i != 3 && i != 7 && i != 15 && i != 31) {
            dozwolone_wzorce_kolumn.push_back(i);
        }
    }
    for (size_t i = 0; i < dozwolone_wzorce_kolumn.size(); ++i) {
        mapa_wzorcow_kolumn[dozwolone_wzorce_kolumn[i]] = i;
    }
}

// Zamienia liczbę na unikalny podzbiór (kombinację) elementów
vector<int> liczba_na_kombinacje(long long ranking, int n, int k) {
    vector<int> wynik;
    int start = 0;
    for (int i = 0; i < k; ++i) {
        for (int v = start; v < n; ++v) {
            long long mozliwosci = dwumian_newtona[n - 1 - v][k - 1 - i];
            if (ranking < mozliwosci) {
                wynik.push_back(v);
                start = v + 1;
                break;
            }
            else {
                ranking -= mozliwosci;
            }
        }
    }
    return wynik;
}

// Zamienia podzbiór z powrotem na liczbę (ranking w porządku leksykograficznym)
long long kombinacja_na_liczbe(const vector<int>& podzbior, int n, int k) {
    long long ranking = 0;
    int start = 0;
    for (int i = 0; i < k; ++i) {
        for (int v = start; v < podzbior[i]; ++v) {
            ranking += dwumian_newtona[n - 1 - v][k - 1 - i];
        }
        start = podzbior[i] + 1;
    }
    return ranking;
}

long long najlepszy_wynik_dekodowania = -1;
vector<int> aktualne_wiersze_kotwicy;

// Funkcja rekurencyjna szukająca Kotwicy i dekodująca zawartość macierzy
void szukaj_kotwicy_i_dekoduj(int poziom, int maska_uzytych, const vector<vector<int>>& macierz) {
    if (poziom == 5) {
        int wzorce_kolumn[10];
        for (int j = 0; j < 10; ++j) {
            int p = 0;
            for (int i = 0; i < 5; ++i) p |= (macierz[aktualne_wiersze_kotwicy[i]][j] << i);
            wzorce_kolumn[j] = p;
        }

        int wymagane_wzorce[5] = { 31, 15, 7, 3, 1 }; // Nasz trójkąt z jedynek
        vector<int> kolumny_kotwicy(5, -1);
        for (int k = 0; k < 5; ++k) {
            for (int j = 0; j < 10; ++j) {
                if (wzorce_kolumn[j] == wymagane_wzorce[k]) {
                    kolumny_kotwicy[k] = j;
                    break;
                }
            }
            if (kolumny_kotwicy[k] == -1) return;
        }

        vector<int> wiersze_danych, kolumny_danych;
        for (int i = 0; i < 10; ++i) {
            bool czy_kotwica = false;
            for (int wk : aktualne_wiersze_kotwicy) if (i == wk) czy_kotwica = true;
            if (!czy_kotwica) wiersze_danych.push_back(i);
        }
        for (int j = 0; j < 10; ++j) {
            bool czy_kotwica = false;
            for (int kk : kolumny_kotwicy) if (j == kk) czy_kotwica = true;
            if (!czy_kotwica) kolumny_danych.push_back(j);
        }

        int wartosci_wierszy[5], wartosci_kolumn[5];
        for (int i = 0; i < 5; ++i) {
            int p = 0;
            for (int j = 0; j < 5; ++j) p |= (macierz[wiersze_danych[i]][kolumny_kotwicy[j]] << j);
            int idx = mapa_wzorcow_wierszy[p];
            if (idx == -1) return;
            wartosci_wierszy[i] = idx;
        }

        for (int j = 0; j < 5; ++j) {
            int p = 0;
            for (int i = 0; i < 5; ++i) p |= (macierz[aktualne_wiersze_kotwicy[i]][kolumny_danych[j]] << i);
            int idx = mapa_wzorcow_kolumn[p];
            if (idx == -1) return;
            wartosci_kolumn[j] = idx;
        }

        // Sprawdzamy unikalność wzorców
        set<int> unik_w, unik_k;
        for (int i = 0; i < 5; ++i) { unik_w.insert(wartosci_wierszy[i]); unik_k.insert(wartosci_kolumn[i]); }
        if (unik_w.size() < 5 || unik_k.size() < 5) return;

        vector<pair<int, int>> posortowane_w, posortowane_k;
        for (int i = 0; i < 5; ++i) posortowane_w.push_back({ wartosci_wierszy[i], wiersze_danych[i] });
        for (int j = 0; j < 5; ++j) posortowane_k.push_back({ wartosci_kolumn[j], kolumny_danych[j] });
        sort(posortowane_w.begin(), posortowane_w.end());
        sort(posortowane_k.begin(), posortowane_k.end());

        vector<int> finalne_idx_w, finalne_idx_k;
        for (int i = 0; i < 5; ++i) finalne_idx_w.push_back(posortowane_w[i].first);
        for (int j = 0; j < 5; ++j) finalne_idx_k.push_back(posortowane_k[j].first);

        long long czesc1 = kombinacja_na_liczbe(finalne_idx_w, 26, 5);
        long long czesc2 = kombinacja_na_liczbe(finalne_idx_k, 26, 5);
        long long czesc3 = 0;
        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 5; ++j) {
                if (macierz[posortowane_w[i].second][posortowane_k[j].second])
                    czesc3 |= (1LL << (i * 5 + j));
            }
        }

        long long kandydat = czesc1 + czesc2 * 65780LL + czesc3 * 65780LL * 65780LL;
        najlepszy_wynik_dekodowania = max(najlepszy_wynik_dekodowania, kandydat);
    }
    else {
        for (int i = 0; i < 10; ++i) {
            if (!(maska_uzytych & (1 << i))) {
                aktualne_wiersze_kotwicy.push_back(i);
                szukaj_kotwicy_i_dekoduj(poziom + 1, maska_uzytych | (1 << i), macierz);
                aktualne_wiersze_kotwicy.pop_back();
            }
        }
    }
}

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

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

    long long limit_n;
    int liczba_testow;
    cin >> limit_n >> liczba_testow;

    przygotuj_tablice_kombinacji();
    przygotuj_wzorce_identyfikacyjne();

    if (rola == "Algosia") {
        while (liczba_testow--) {
            long long liczba_do_wyslania;
            cin >> liczba_do_wyslania;
            long long licznik_bezpieczenstwa = 0;

            while (true) {
                long long pelna_liczba = liczba_do_wyslania + licznik_bezpieczenstwa * POJEMNOSC_MODULO;
                long long czesc1 = pelna_liczba % 65780;
                long long reszta = pelna_liczba / 65780;
                long long czesc2 = reszta % 65780;
                long long czesc3 = reszta / 65780;

                vector<int> r_idx = liczba_na_kombinacje(czesc1, 26, 5);
                vector<int> c_idx = liczba_na_kombinacje(czesc2, 26, 5);

                vector<vector<int>> macierz(10, vector<int>(10, 0));
                int wzor_kotwicy[5][5] = {
                    {1, 1, 1, 1, 1}, {1, 1, 1, 1, 0}, {1, 1, 1, 0, 0}, {1, 1, 0, 0, 0}, {1, 0, 0, 0, 0}
                };
                for (int i = 0; i < 5; ++i)
                    for (int j = 0; j < 5; ++j)
                        macierz[i][j] = wzor_kotwicy[i][j];

                for (int k = 0; k < 5; ++k) {
                    int pat = dozwolone_wzorce_wierszy[r_idx[k]];
                    for (int j = 0; j < 5; ++j) macierz[5 + k][j] = (pat >> j) & 1;
                }
                for (int k = 0; k < 5; ++k) {
                    int pat = dozwolone_wzorce_kolumn[c_idx[k]];
                    for (int i = 0; i < 5; ++i) macierz[i][5 + k] = (pat >> i) & 1;
                }
                for (int i = 0; i < 5; ++i) {
                    for (int j = 0; j < 5; ++j) {
                        macierz[5 + i][5 + j] = (czesc3 >> (i * 5 + j)) & 1;
                    }
                }

                najlepszy_wynik_dekodowania = -1;
                aktualne_wiersze_kotwicy.clear();
                szukaj_kotwicy_i_dekoduj(0, 0, macierz);

                if (najlepszy_wynik_dekodowania == pelna_liczba) {
                    for (int i = 0; i < 10; ++i) {
                        for (int j = 0; j < 10; ++j) cout << macierz[i][j];
                        cout << "\n";
                    }
                    cout << flush;
                    break;
                }
                licznik_bezpieczenstwa++;
            }
        }
    }
    else {
        while (liczba_testow--) {
            vector<vector<int>> macierz(10, vector<int>(10, 0));
            for (int i = 0; i < 10; ++i) {
                string wiersz_str; cin >> wiersz_str;
                for (int j = 0; j < 10; ++j) macierz[i][j] = wiersz_str[j] - '0';
            }
            najlepszy_wynik_dekodowania = -1;
            aktualne_wiersze_kotwicy.clear();
            szukaj_kotwicy_i_dekoduj(0, 0, macierz);
            cout << (najlepszy_wynik_dekodowania % POJEMNOSC_MODULO) << "\n" << flush;
        }
    }
    return 0;
}