// Author : Jakub Rożek
// Task   : KOD - Kodowanie macierzami [B]
// Memory : 
// Time   : 

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

using ll = long long;

const int ROZMIAR = 10;
const int LICZBA_PODZIALOW = 1 << (ROZMIAR - 1);
const int LICZBA_MASEK = 1 << ROZMIAR;
const ll NIEPOLICZONE = numeric_limits<ll>::max();
int jedynki_w_masce[LICZBA_MASEK];

struct Przejscie {
    int maska;
    int nastepny_podzial;
    bool operator<(const Przejscie& inny) const {
        int jedynki_moje = jedynki_w_masce[maska];
        int jedynki_inne = jedynki_w_masce[inny.maska];
        if (jedynki_moje != jedynki_inne) return jedynki_moje < jedynki_inne;
        return maska < inny.maska;
    }
};

vector<int> rozmiary_podzialu[LICZBA_PODZIALOW];
vector<Przejscie> przejscia[LICZBA_PODZIALOW];
// dp[wiersze_pozostale][id_podzialu][dolna_maska] = liczba dopelnien
ll dp[ROZMIAR+1][LICZBA_PODZIALOW][LICZBA_MASEK];

int zakoduj_podzial(vector<int> &rozmiary) {
    int id = 0;
    int pozycja = 0;
    for (int i=0; i+1<(int)rozmiary.size(); ++i) {
        pozycja += rozmiary[i];
        id |= 1 << (pozycja - 1);
    }
    return id;
}

int zbuduj_maske_z_licznosci(vector<int> &rozmiary, vector<int> &licznosci) {
    int maska = 0;
    int pozycja = 0;
    for (int i=0; i<(int)rozmiary.size(); ++i) {
        for (int j=rozmiary[i]-licznosci[i]; j<rozmiary[i]; ++j) {
            maska |= 1 << (pozycja + j);
        }
        pozycja += rozmiary[i];
    }
    return maska;
}

vector<int> licznosci_z_wiersza(int wiersz, vector<int> &rozmiary) {
    vector<int> licznosci;
    int pozycja = 0;
    for (int i : rozmiary) {
        int jedynki = 0;
        for (int j=0; j<i; ++j) {
            jedynki += (wiersz >> (pozycja+j)) & 1;
        }
        licznosci.push_back(jedynki);
        pozycja += i;
    }
    return licznosci;
}

int kanoniczna_maska_wiersza(int wiersz, vector<int> &rozmiary) {
    vector<int> licznosci = licznosci_z_wiersza(wiersz, rozmiary);
    return zbuduj_maske_z_licznosci(rozmiary, licznosci);
}

int podziel_podzial(int id_podzialu, vector<int> &licznosci) {
    auto &rozmiary = rozmiary_podzialu[id_podzialu];
    vector<int> nastepne_rozmiary;
    for (int i=0; i<(int)rozmiary.size(); ++i) {
        int zera = rozmiary[i] - licznosci[i];
        int jedynki = licznosci[i];
        if (zera > 0) nastepne_rozmiary.push_back(zera);
        if (jedynki > 0) nastepne_rozmiary.push_back(jedynki);
    }
    return zakoduj_podzial(nastepne_rozmiary);
}

bool maska_dopuszczalna(int dolna_maska, int kandydat) {
    int jedynki_dolna = jedynki_w_masce[dolna_maska];
    int jedynki_kandydat = jedynki_w_masce[kandydat];
    return jedynki_kandydat > jedynki_dolna ||
           (jedynki_kandydat == jedynki_dolna && kandydat >= dolna_maska);
}

void inicjalizuj_podzialy() {
    for (int maska_ciec=0; maska_ciec<LICZBA_PODZIALOW; ++maska_ciec) {
        vector<int> rozmiary;
        int x = 1;
        for (int i=0; i<ROZMIAR-1; ++i) {
            if ((maska_ciec >> i) & 1) {
                rozmiary.push_back(x);
                x = 1;
            } else {
                ++x;
            }
        }
        rozmiary.push_back(x);
        rozmiary_podzialu[maska_ciec] = rozmiary;
    }
}

void inicjalizuj_przejscia() {
    vector<int> licznosci;
    for (int id=0; id<LICZBA_PODZIALOW; ++id) {
        function<void(int)> generuj = [&](int indeks) {
            if (indeks == (int)rozmiary_podzialu[id].size()) {
                int maska = zbuduj_maske_z_licznosci(rozmiary_podzialu[id], licznosci);
                int nastepny_podzial = podziel_podzial(id, licznosci);
                przejscia[id].push_back({maska, nastepny_podzial});
                return;
            }
            for (int ile=0; ile<=rozmiary_podzialu[id][indeks]; ++ile) {
                licznosci.push_back(ile);
                generuj(indeks + 1);
                licznosci.pop_back();
            }
        };
        generuj(0);
        sort(przejscia[id].begin(), przejscia[id].end());
    }
}

ll policz_dp(int wiersze_pozostale, int id_podzialu, int dolna_maska) {
    ll &zapamietane = dp[wiersze_pozostale][id_podzialu][dolna_maska];
    if (zapamietane != NIEPOLICZONE) return zapamietane;
    if (wiersze_pozostale == 0) return zapamietane = 1;
    zapamietane = 0;
    for (auto &przejscie : przejscia[id_podzialu]) {
        if (!maska_dopuszczalna(dolna_maska, przejscie.maska)) continue;
        zapamietane += policz_dp(wiersze_pozostale - 1, przejscie.nastepny_podzial, przejscie.maska);
    }
    return zapamietane;
}

string maska_na_napis(int maska) {
    string napis(ROZMIAR, '0');
    for (int i=0; i<ROZMIAR; ++i) {
        if ((maska >> i) & 1) napis[i] = '1';
    }
    return napis;
}

int napis_na_maske(string& napis) {
    int maska = 0;
    for (int i=0; i<ROZMIAR; ++i) {
        if (napis[i] == '1') maska |= 1 << i;
    }
    return maska;
}

vector<int> numer_na_macierz(ll numer) {
    vector<int> wiersze;
    int wiersze_pozostale = ROZMIAR;
    vector<int> rozmiary_temp = {ROZMIAR};
    int id_podzialu = zakoduj_podzial(rozmiary_temp);
    int dolna_maska = 0;
    while (wiersze_pozostale > 0) {
        for (auto &przejscie : przejscia[id_podzialu]) {
            if (!maska_dopuszczalna(dolna_maska, przejscie.maska)) continue;
            ll ile = policz_dp(wiersze_pozostale-1, przejscie.nastepny_podzial, przejscie.maska);
            if (numer > ile) {
                numer -= ile;
                continue;
            }
            wiersze.push_back(przejscie.maska);
            dolna_maska = przejscie.maska;
            id_podzialu = przejscie.nastepny_podzial;
            --wiersze_pozostale;
            break;
        }
    }
    return wiersze;
}

ll macierz_na_numer(vector<int>& kanoniczne_wiersze) {
    ll numer = 1;
    int wiersze_pozostale = ROZMIAR;
    vector<int> rozmiary_temp = {ROZMIAR};
    int id_podzialu = zakoduj_podzial(rozmiary_temp);
    int dolna_maska = 0;
    for (int maska_wiersza : kanoniczne_wiersze) {
        for (auto& przejscie : przejscia[id_podzialu]) {
            if (!maska_dopuszczalna(dolna_maska, przejscie.maska)) continue;
            if (przejscie.maska == maska_wiersza) {
                id_podzialu = przejscie.nastepny_podzial;
                dolna_maska = przejscie.maska;
                --wiersze_pozostale;
                break;
            }
            numer += policz_dp(wiersze_pozostale-1, przejscie.nastepny_podzial, przejscie.maska);
        }
    }
    return numer;
}

vector<int> zbuduj_permutacje_kolumn(int maska_wiersza, vector<int> &rozmiary) {
    vector<int> permutacja;
    int pozycja = 0;
    for (int r : rozmiary) {
        for (int j=0; j<r; ++j) {
            if (((maska_wiersza >> (pozycja+j)) & 1) == 0) permutacja.push_back(pozycja+j);
        }
        for (int j=0; j<r; ++j) {
            if (((maska_wiersza >> (pozycja+j)) & 1) == 1) permutacja.push_back(pozycja+j);
        }
        pozycja += r;
    }
    return permutacja;
}

int przestaw_wiersz(int maska_wiersza, vector<int>& permutacja) {
    int wynik = 0;
    for (int i=0; i<ROZMIAR; ++i) {
        if ((maska_wiersza >> permutacja[i]) & 1) {
            wynik |= 1 << i;
        }
    }
    return wynik;
}

bool backtrack(vector<int> wiersze, int id_podzialu, int dolna_maska, vector<int>& kanoniczne_wiersze) {
    if (wiersze.empty()) return true;
    auto& rozmiary = rozmiary_podzialu[id_podzialu];
    int jedynki_dolna = jedynki_w_masce[dolna_maska];

    int najmniej_jedynek = ROZMIAR + 1;
    for (int wiersz : wiersze) {
        najmniej_jedynek = min(najmniej_jedynek, jedynki_w_masce[wiersz]);
    }
    if (najmniej_jedynek < jedynki_dolna) return false;

    sort(wiersze.begin(), wiersze.end());
    int poprzedni_wiersz = -1;
    for (int i=0; i<(int)wiersze.size(); ++i) {
        if (jedynki_w_masce[wiersze[i]] != najmniej_jedynek) continue;
        if (wiersze[i] == poprzedni_wiersz) continue;
        poprzedni_wiersz = wiersze[i];

        int wybrany_wiersz = wiersze[i];
        int maska_kanoniczna = kanoniczna_maska_wiersza(wybrany_wiersz, rozmiary);
        if (!maska_dopuszczalna(dolna_maska, maska_kanoniczna)) continue;

        vector<int> licznosci = licznosci_z_wiersza(wybrany_wiersz, rozmiary);
        int nastepny_podzial = podziel_podzial(id_podzialu, licznosci);
        vector<int> permutacja = zbuduj_permutacje_kolumn(wybrany_wiersz, rozmiary);

        vector<int> nastepne_wiersze;
        for (int j=0; j<(int)wiersze.size(); ++j) {
            if (j == i) continue;
            nastepne_wiersze.push_back(przestaw_wiersz(wiersze[j], permutacja));
        }

        if (backtrack(nastepne_wiersze, nastepny_podzial, maska_kanoniczna, kanoniczne_wiersze)) {
            kanoniczne_wiersze.insert(kanoniczne_wiersze.begin(), maska_kanoniczna);
            return true;
        }
    }

    return false;
}

vector<int> kanonizuj_odebrana_macierz(vector<int> &odebrane_wiersze) {
    vector<int> kanoniczne_wiersze;
    vector<int> rozmiary_temp = {ROZMIAR};
    backtrack(odebrane_wiersze, zakoduj_podzial(rozmiary_temp), 0, kanoniczne_wiersze);
    return kanoniczne_wiersze;
}

void inicjalizuj_wszystko() {
    for (int maska = 0; maska < LICZBA_MASEK; ++maska) {
        jedynki_w_masce[maska] = __builtin_popcount(maska);
    }
    inicjalizuj_podzialy();
    inicjalizuj_przejscia();
    for (int i=0; i<=ROZMIAR; ++i) {
        for (int j=0; j<LICZBA_PODZIALOW; ++j) {
            for (int k=0; k<LICZBA_MASEK; ++k) {
                dp[i][j][k] = NIEPOLICZONE;
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    inicjalizuj_wszystko();

    string rola;
    ll n, x;
    int t;
    cin >> rola >> n >> t;

    if (rola == "Algosia") {
        for (int nr_testu=0; nr_testu<t; ++nr_testu) {
            cin >> x;
            vector<int> wiersze = numer_na_macierz(x);
            for (int maska_wiersza : wiersze) {
                cout << maska_na_napis(maska_wiersza) << '\n';
            }
            cout.flush();
        }
    } else {
        vector<int> tmp = numer_na_macierz(20000000000000LL); // W wolnym czasie rozgrzewam sobie dp.
        for (int nr_testu=0; nr_testu<t; ++nr_testu) {
            vector<int> odebrane_wiersze;
            for (int i=0; i<ROZMIAR; ++i) {
                string napis;
                cin >> napis;
                odebrane_wiersze.push_back(napis_na_maske(napis));
            }
            vector<int> kanoniczne_wiersze = kanonizuj_odebrana_macierz(odebrane_wiersze);
            ll odpowiedz = macierz_na_numer(kanoniczne_wiersze);
            cout << odpowiedz << '\n';
            cout.flush();
        }
    }

    return 0;
}