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

using ull = unsigned long long;

struct RodzinkaFusow {
    array<int, 10> kody;
    int rozne_stopnie;
    int rozrzut;
    int zadyma;
    uint64_t klucz;
};

static const int ile_bitow_glownego_bigosu = 23;
static const int ile_bitow_kontroli = 13;
static const ull maska_glownego_bigosu = (1ULL << ile_bitow_glownego_bigosu) - 1;
static const ull maska_kontroli = (1ULL << ile_bitow_kontroli) - 1;
static const int ile_rodzinek = 2200;

vector<array<int, 10>> wszystkie_rodzinki;
unordered_map<uint64_t, int> mapa_rodzinek;

vector<array<int, 4>> podzbiory_wierszy;
vector<array<int, 6>> dopelniacze_wierszy;
array<int, 1 << 10> indeks_maski_wierszy;

vector<array<int, 6>> podzbiory_kolumnowych_etykiet;
unordered_map<uint64_t, int> mapa_szablonow;

vector<array<int, 4>> wszystkie_kotwice;

ull pojemnosc_calosci = 0;

uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15ULL;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
    x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
    x ^= x >> 31;
    return x;
}

ull zrob_kontrole(int rodzinka, int wybrane_wiersze, int szablon, ull glowny_bigos) {
    uint64_t breja = 0x123456789abcdef0ULL;
    breja ^= splitmix64((uint64_t)(rodzinka + 1) * 0x9e3779b97f4a7c15ULL);
    breja ^= splitmix64((uint64_t)(wybrane_wiersze + 3) * 0xbf58476d1ce4e5b9ULL);
    breja ^= splitmix64((uint64_t)(szablon + 5) * 0x94d049bb133111ebULL);
    breja ^= splitmix64((uint64_t)(glowny_bigos + 7) * 0x243f6a8885a308d3ULL);
    return breja & maska_kontroli;
}

uint64_t spakuj_dziesiec(const array<int, 10>& pyzy) {
    uint64_t wynik = 0;
    for (int i = 0; i < 10; ++i) wynik = (wynik << 4) | (uint64_t)pyzy[i];
    return wynik;
}

uint64_t spakuj_szesc(const array<int, 6>& pyzy) {
    uint64_t wynik = 0;
    for (int i = 0; i < 6; ++i) wynik = (wynik << 4) | (uint64_t)pyzy[i];
    return wynik;
}

void ugotuj_wiersze() {
    indeks_maski_wierszy.fill(-1);
    for (int maska = 0; maska < (1 << 10); ++maska) {
        if (__builtin_popcount((unsigned)maska) != 4) continue;
        array<int, 4> wybrane{};
        array<int, 6> reszta{};
        int a = 0, b = 0;
        for (int i = 0; i < 10; ++i) {
            if (maska & (1 << i)) wybrane[a++] = i;
            else reszta[b++] = i;
        }
        indeks_maski_wierszy[maska] = (int)podzbiory_wierszy.size();
        podzbiory_wierszy.push_back(wybrane);
        dopelniacze_wierszy.push_back(reszta);
    }
}

void ugotuj_szablony() {
    for (int maska = 0; maska < (1 << 16); ++maska) {
        if (__builtin_popcount((unsigned)maska) != 6) continue;
        array<int, 6> etykietki{};
        int ptr = 0;
        for (int i = 0; i < 16; ++i) if (maska & (1 << i)) etykietki[ptr++] = i;
        mapa_szablonow[spakuj_szesc(etykietki)] = (int)podzbiory_kolumnowych_etykiet.size();
        podzbiory_kolumnowych_etykiet.push_back(etykietki);
    }
}

void ugotuj_kotwice() {
    for (int a = 0; a < 10; ++a) {
        for (int b = 0; b < 10; ++b) if (b != a) {
            for (int c = 0; c < 10; ++c) if (c != a && c != b) {
                for (int d = 0; d < 10; ++d) if (d != a && d != b && d != c) {
                    wszystkie_kotwice.push_back({a, b, c, d});
                }
            }
        }
    }
}

void ugotuj_rodzinki() {
    vector<RodzinkaFusow> magazyn;
    for (int maska = 0; maska < (1 << 16); ++maska) {
        if (__builtin_popcount((unsigned)maska) != 10) continue;
        array<int, 10> pyzy{};
        int ptr = 0;
        for (int i = 0; i < 16; ++i) if (maska & (1 << i)) pyzy[ptr++] = i;
        array<int, 4> stopnie{};
        for (int bit = 0; bit < 4; ++bit) {
            int suma = 0;
            for (int i = 0; i < 10; ++i) suma += (pyzy[i] >> bit) & 1;
            stopnie[bit] = suma;
        }
        int rozne = (int)set<int>(stopnie.begin(), stopnie.end()).size();
        int mini = 100, maxi = -100;
        for (int x : stopnie) {
            mini = min(mini, x);
            maxi = max(maxi, x);
        }
        int zadyma = 0;
        for (int i = 0; i < 4; ++i) for (int j = 0; j < i; ++j) zadyma += abs(stopnie[i] - stopnie[j]);
        magazyn.push_back({pyzy, rozne, maxi - mini, zadyma, spakuj_dziesiec(pyzy)});
    }
    sort(magazyn.begin(), magazyn.end(), [](const RodzinkaFusow& a, const RodzinkaFusow& b) {
        if (a.rozne_stopnie != b.rozne_stopnie) return a.rozne_stopnie > b.rozne_stopnie;
        if (a.rozrzut != b.rozrzut) return a.rozrzut > b.rozrzut;
        if (a.zadyma != b.zadyma) return a.zadyma > b.zadyma;
        return a.klucz < b.klucz;
    });
    wszystkie_rodzinki.reserve(ile_rodzinek);
    for (int i = 0; i < ile_rodzinek; ++i) {
        wszystkie_rodzinki.push_back(magazyn[i].kody);
        mapa_rodzinek[magazyn[i].klucz] = i;
    }
}

void ugotuj_wszystko() {
    ugotuj_wiersze();
    ugotuj_szablony();
    ugotuj_kotwice();
    ugotuj_rodzinki();
    pojemnosc_calosci = (ull)ile_rodzinek;
    pojemnosc_calosci *= (ull)podzbiory_wierszy.size();
    pojemnosc_calosci *= (ull)podzbiory_kolumnowych_etykiet.size();
    pojemnosc_calosci *= (1ULL << ile_bitow_glownego_bigosu);
}

ull zloz_numer(int rodzinka, int wiersze, int szablon, ull glowny_bigos) {
    ull wynik = rodzinka;
    wynik = wynik * (ull)podzbiory_wierszy.size() + (ull)wiersze;
    wynik = wynik * (ull)podzbiory_kolumnowych_etykiet.size() + (ull)szablon;
    wynik = wynik * (1ULL << ile_bitow_glownego_bigosu) + glowny_bigos;
    return wynik + 1;
}

void rozloz_numer(ull numer, int& rodzinka, int& wiersze, int& szablon, ull& glowny_bigos) {
    ull bieda = numer - 1;
    glowny_bigos = bieda & maska_glownego_bigosu;
    bieda >>= ile_bitow_glownego_bigosu;
    szablon = (int)(bieda % (ull)podzbiory_kolumnowych_etykiet.size());
    bieda /= (ull)podzbiory_kolumnowych_etykiet.size();
    wiersze = (int)(bieda % (ull)podzbiory_wierszy.size());
    bieda /= (ull)podzbiory_wierszy.size();
    rodzinka = (int)bieda;
}

vector<string> zakoduj(ull numer) {
    int rodzinka, wiersze, szablon;
    ull glowny_bigos;
    rozloz_numer(numer, rodzinka, wiersze, szablon, glowny_bigos);

    ull kontrola = zrob_kontrole(rodzinka, wiersze, szablon, glowny_bigos);
    ull wielki_pierog = glowny_bigos | (kontrola << ile_bitow_glownego_bigosu);

    vector<string> macierz_z_majonezem(10, string(10, '0'));

    const auto& pyzy = wszystkie_rodzinki[rodzinka];
    for (int wiersz = 0; wiersz < 10; ++wiersz) {
        int kod = pyzy[wiersz];
        for (int bit = 0; bit < 4; ++bit) {
            if ((kod >> bit) & 1) macierz_z_majonezem[wiersz][bit] = '1';
        }
    }

    const auto& wybrane = podzbiory_wierszy[wiersze];
    const auto& reszta = dopelniacze_wierszy[wiersze];
    const auto& etykietki = podzbiory_kolumnowych_etykiet[szablon];

    for (int kolumna = 0; kolumna < 6; ++kolumna) {
        int wzor = etykietki[kolumna];
        for (int i = 0; i < 4; ++i) {
            if ((wzor >> i) & 1) macierz_z_majonezem[wybrane[i]][4 + kolumna] = '1';
        }
    }

    for (int i = 0; i < 6; ++i) {
        int wiersz = reszta[i];
        ull kawalek = (wielki_pierog >> (6 * i)) & 63ULL;
        for (int kolumna = 0; kolumna < 6; ++kolumna) {
            if ((kawalek >> kolumna) & 1ULL) macierz_z_majonezem[wiersz][4 + kolumna] = '1';
        }
    }

    return macierz_z_majonezem;
}

struct Trop {
    ull numer;
    int rodzinka;
    int wiersze;
    int szablon;
};

Trop lepszy_trop(const Trop& a, const Trop& b) {
    if (a.numer == 0) return b;
    if (b.numer == 0) return a;
    if (a.szablon != b.szablon) return (a.szablon > b.szablon ? a : b);
    if (a.wiersze != b.wiersze) return (a.wiersze > b.wiersze ? a : b);
    if (a.rodzinka != b.rodzinka) return (a.rodzinka > b.rodzinka ? a : b);
    if (a.numer != b.numer) return (a.numer > b.numer ? a : b);
    return a;
}

ull odkoduj(const vector<string>& macierz_z_majonezem, ull limit_n) {
    int kolumnowe_maski[10];
    for (int c = 0; c < 10; ++c) {
        int maska = 0;
        for (int r = 0; r < 10; ++r) if (macierz_z_majonezem[r][c] == '1') maska |= 1 << r;
        kolumnowe_maski[c] = maska;
    }

    Trop najlepszy{0, -1, -1, -1};
    unordered_set<ull> bylo;
    bylo.reserve(256);

    int kody_wierszy[10];
    int posortowane[10];
    int wiersz_po_etykiecie[10];
    int zostale_kolumny[6];
    int wzorki[6];
    int kolejnosc[6];

    for (const auto& kotwica : wszystkie_kotwice) {
        bool dubel = false;
        int maska_kodow = 0;
        for (int r = 0; r < 10; ++r) {
            int kod = 0;
            kod |= ((kolumnowe_maski[kotwica[0]] >> r) & 1) << 0;
            kod |= ((kolumnowe_maski[kotwica[1]] >> r) & 1) << 1;
            kod |= ((kolumnowe_maski[kotwica[2]] >> r) & 1) << 2;
            kod |= ((kolumnowe_maski[kotwica[3]] >> r) & 1) << 3;
            if (maska_kodow & (1 << kod)) {
                dubel = true;
                break;
            }
            maska_kodow |= 1 << kod;
            kody_wierszy[r] = kod;
            posortowane[r] = kod;
        }
        if (dubel) continue;

        sort(posortowane, posortowane + 10);
        array<int, 10> pyzy{};
        for (int i = 0; i < 10; ++i) pyzy[i] = posortowane[i];
        auto it_rodzinka = mapa_rodzinek.find(spakuj_dziesiec(pyzy));
        if (it_rodzinka == mapa_rodzinek.end()) continue;
        int rodzinka = it_rodzinka->second;

        for (int r = 0; r < 10; ++r) {
            int etykieta = (int)(lower_bound(posortowane, posortowane + 10, kody_wierszy[r]) - posortowane);
            wiersz_po_etykiecie[etykieta] = r;
        }

        int ptr = 0;
        bool czy_kotwica[10] = {};
        czy_kotwica[kotwica[0]] = true;
        czy_kotwica[kotwica[1]] = true;
        czy_kotwica[kotwica[2]] = true;
        czy_kotwica[kotwica[3]] = true;
        for (int c = 0; c < 10; ++c) if (!czy_kotwica[c]) zostale_kolumny[ptr++] = c;

        for (int idx_wierszy = 0; idx_wierszy < (int)podzbiory_wierszy.size(); ++idx_wierszy) {
            const auto& wybrane = podzbiory_wierszy[idx_wierszy];

            bool zly = false;
            int maska_wzorkow = 0;
            for (int i = 0; i < 6; ++i) {
                int c = zostale_kolumny[i];
                int wzor = 0;
                wzor |= ((kolumnowe_maski[c] >> wiersz_po_etykiecie[wybrane[0]]) & 1) << 0;
                wzor |= ((kolumnowe_maski[c] >> wiersz_po_etykiecie[wybrane[1]]) & 1) << 1;
                wzor |= ((kolumnowe_maski[c] >> wiersz_po_etykiecie[wybrane[2]]) & 1) << 2;
                wzor |= ((kolumnowe_maski[c] >> wiersz_po_etykiecie[wybrane[3]]) & 1) << 3;
                if (maska_wzorkow & (1 << wzor)) {
                    zly = true;
                    break;
                }
                maska_wzorkow |= 1 << wzor;
                wzorki[i] = wzor;
            }
            if (zly) continue;

            array<int, 6> pyzy_szablonu{};
            for (int i = 0; i < 6; ++i) pyzy_szablonu[i] = wzorki[i];
            sort(pyzy_szablonu.begin(), pyzy_szablonu.end());
            auto it_szablon = mapa_szablonow.find(spakuj_szesc(pyzy_szablonu));
            if (it_szablon == mapa_szablonow.end()) continue;
            int szablon = it_szablon->second;

            for (int i = 0; i < 6; ++i) kolejnosc[i] = i;
            sort(kolejnosc, kolejnosc + 6, [&](int a, int b) {
                return wzorki[a] < wzorki[b];
            });

            const auto& reszta = dopelniacze_wierszy[idx_wierszy];
            ull wielki_pierog = 0;
            for (int i = 0; i < 6; ++i) {
                int rr = wiersz_po_etykiecie[reszta[i]];
                ull kawalek = 0;
                for (int j = 0; j < 6; ++j) {
                    int c = zostale_kolumny[kolejnosc[j]];
                    if ((kolumnowe_maski[c] >> rr) & 1) kawalek |= 1ULL << j;
                }
                wielki_pierog |= kawalek << (6 * i);
            }

            ull glowny_bigos = wielki_pierog & maska_glownego_bigosu;
            ull kontrola = (wielki_pierog >> ile_bitow_glownego_bigosu) & maska_kontroli;
            if (kontrola != zrob_kontrole(rodzinka, idx_wierszy, szablon, glowny_bigos)) continue;

            ull numer = zloz_numer(rodzinka, idx_wierszy, szablon, glowny_bigos);
            if (numer < 1 || numer > limit_n) continue;
            if (bylo.insert(numer).second) {
                Trop nowy{numer, rodzinka, idx_wierszy, szablon};
                najlepszy = lepszy_trop(najlepszy, nowy);
            }
        }
    }

    if (najlepszy.numer == 0) return 1;
    return najlepszy.numer;
}

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

    ugotuj_wszystko();

    string kto_tu_kisnie;
    ull limit_n;
    int ile_prob;
    cin >> kto_tu_kisnie >> limit_n >> ile_prob;

    if (kto_tu_kisnie == "Algosia") {
        while (ile_prob--) {
            ull numer;
            cin >> numer;
            if (numer > pojemnosc_calosci) numer = (numer - 1) % pojemnosc_calosci + 1;
            vector<string> macierz = zakoduj(numer);
            for (int i = 0; i < 10; ++i) cout << macierz[i] << '\n';
            cout.flush();
        }
    } else {
        while (ile_prob--) {
            vector<string> macierz(10);
            for (int i = 0; i < 10; ++i) cin >> macierz[i];
            ull numer = odkoduj(macierz, limit_n);
            cout << numer << '\n';
            cout.flush();
        }
    }

    return 0;
}