#ifndef LOCAL
#pragma GCC optimize("O3")
#endif
//#include <bits/stdc++.h>
#include <bit>
#include <print>
#include <iostream>
#include <cassert>
#include <random>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <algorithm>
#include <functional>
#include <ranges>
#include <numeric>
#define FOR(i,p,k) for(int i=(p); i<=(k); ++i)
#define REP(i,k) FOR(i,0,(k)-1)
#define RFOR(i,p,n) for(int i=(p); i>=(n); --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define ssize(x) int((x).size())
#define fi first
#define se second
#define V vector
#define pb push_back
#define eb emplace_back
#define C const
#define pn printf("\n")
using namespace std;
typedef long long ll;
typedef V <int> vi;
typedef V <ll> vll;
typedef C int ci;
typedef C ll cll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
void chmin(auto &a, auto b){a=min(a,b);}
void chmax(auto &a, auto b){a=max(a,b);}
ci inf=2.1e9;
cll infll=4.5e18;
int I(){
    int r;
    cin >> r;
    return r;
}
ll LL(){
    ll r;
    cin >> r;
    return r;
}
constexpr int sil(ci n) {
    int w=1;
    FOR(i, 2, n)
        w*=i;
    return w;
}
constexpr int newt(ci n, ci k) {
    return sil(n)/sil(k)/sil(n-k);
}
[[maybe_unused]] constexpr int newtwielu(ci n, C auto &kv) {
    int w=0;
    for (ci k : kv)
        w += newt(n, k);
    return w;
}
constexpr int dajmozlbez5() {
    int mozl=0;
    for (ci i : {0, 1, 2, 3, 4, 6, 7, 8, 9, 10})
        mozl+=newt(10, i);
    return mozl;
}
struct kodbez5t{
    static ci mozl=dajmozlbez5();
    vi mp,revmp;
    kodbez5t() {
        mp.resize(mozl, -1);
        revmp.resize(1<<10, -1);
        int nast=0;
        REP(i, 1<<10) {
            if (popcount(unsigned(i))!=5) {
                revmp[i]=nast;
                mp[nast]=i;
                ++nast;
            }
        }
        assert(nast==mozl);
    }
    vi map(ci cyf) {
        int msk=mp[cyf];
        vi v(10);
        REP(i, 10)
            v[i]=msk>>i&1;
        return v;
    }
    int odmap(C vi &v) {
        int msk=0;
        REP(i, 10)
            msk|=v[i]<<i;
        return revmp[msk];
    }
} kodbez5;

struct numkodt {
    static constexpr ci mozl=kodbez5.mozl;
    ci dl=6;
    V <vll> prp;
    numkodt() {
        prp.resize(dl+1, vll(mozl));
        REP(i, mozl)
            prp[1][i]=i+1;
        FOR(d, 2, dl) {
            REP(i, mozl) {
                prp[d][i]=prp[d-1][i];
                if (i)
                    prp[d][i]+=prp[d][i-1];
            }
        }
    }
    // Daje rosnąco.
    vi zakoduj(ll n) {
        assert(n>0);
        vi wyn(dl, -1);
        RFOR(d, dl, 1) {
            REP(i, mozl) {
                if (prp[d][i]>=n) {
                    if (i)
                        n-=prp[d][i-1];
                    wyn[dl-d]=i;
                    break;
                }
            }
            assert(wyn[dl-d]!=-1);
        }
        assert(n==1);
        return wyn;
    }
    ll odkoduj(vi kolumny) {
        sort(all(kolumny));
        reverse(all(kolumny));
        ll n=1;
        REP(d, dl) {
            ci i=kolumny[d];
            if (i)
                n += prp[dl-d][i-1];
        }
        return n;
    }
} numkod;

C V <vi> patnumkol={
    {0, 0, 0, 0, 0, 1, 1, 1, 1, 1},
    {0, 0, 0, 1, 1, 1, 1, 1, 0, 0},
    {0, 0, 1, 0, 1, 1, 1, 0, 0, 1},
    {0, 1, 1, 0, 0, 0, 1, 1, 1, 0}
};
// Wiersz i przeniósł się do wynwier[i].
vi odkodnumkol(V <vi> kol5) {
    assert(ssize(kol5)==4);
    vi ilezapwkol(10);
    REP(c, 10)
        REP(i, 4)
            ilezapwkol[c]+=kol5[i][c];
    {
        int k=-1;
        REP(i, 4) {
            bool czy1=0;
            REP(a, 10)
                if (kol5[i][a]==1&&ilezapwkol[a]==1) {
                    czy1=1;
                    break;
                }
            if (!czy1)
                continue;
            int ile2zap=0;
            REP(a, 10)
                ile2zap+=kol5[i][a]==1&&ilezapwkol[a]==2;
            if (ile2zap==2) {
                assert(k==-1);
                k=i;
            }
        }
        assert(k!=-1);
        swap(kol5[k], kol5.back());
    }
    vi ilezapbezost(10);
    REP(c, 10)
        REP(i, 3)
            ilezapbezost[c]+=kol5[i][c];
    vi gdziekol(3, -1);
    REP(c, 10) {
        if (ilezapbezost[c]==2&&kol5.back()[c]) {
            REP(i, 3)
                if (!kol5[i][c])
                    gdziekol[2]=i;
        }
        if (ilezapbezost[c]==1&&!kol5.back()[c]) {
            REP(i, 3)
                if (kol5[i][c])
                    gdziekol[1]=i;
        }
    }
    assert(gdziekol[2]!=-1&&gdziekol[1]!=-1&&gdziekol[0]==-1);
    REP(i, 3) {
        bool czy=1;
        REP(j, 3)
            czy&=gdziekol[j]!=i;
        if (czy) {
            assert(gdziekol[0]==-1);
            gdziekol[0]=i;
        }
    }
    REP(i, 3)
        REP(j, 3) {
            if (i!=j)
                assert(gdziekol[i]!=gdziekol[j]);
            else
                assert(gdziekol[i]!=-1);
        }
    V <vi> uporz;
    REP(i, 3)
        uporz.eb(std::move(kol5[gdziekol[i]]));
    uporz.eb(std::move(kol5.back()));
    // Wiersz i przeniósł się do wynwier[i].
    vi wynwier(10, -1);
    REP(i, 10) {
        REP(j, 10) {
            bool czy=1;
            REP(a, 4)
                czy&=patnumkol[a][i]==uporz[a][j];
            if (czy) {
                assert(wynwier[i]==-1);
                wynwier[i]=j;
            }
        }
        assert(wynwier[i]!=-1);
    }
    return wynwier;
}
ll odkoduj(V <vi> kolumny) {
    V <vi> reszta,piątki;
    while (ssize(kolumny)) {
        if (accumulate(all(kolumny.back()), 0)==5)
            piątki.eb(std::move(kolumny.back()));
        else
            reszta.eb(std::move(kolumny.back()));
        kolumny.pop_back();
    }
    assert(ssize(piątki)==4);
    assert(ssize(reszta)==6);
    C vi wynwier=odkodnumkol(piątki);
    V <vi> odshuf=reszta;
    REP(i, 6) {
        REP(c, 10)
            odshuf[i][c]=reszta[i][wynwier[c]];
    }
    vi cyfry;
    for (C vi &v : odshuf)
        cyfry.eb(kodbez5.odmap(v));
    cll wyn=numkod.odkoduj(cyfry);
    return wyn;
}
// Zwraca KOLUMNY.
V <vi> zakoduj(ll n) {
    V <vi> kolumny=patnumkol;
    for (ci cyfra : numkod.zakoduj(n))
        kolumny.eb(kodbez5.map(cyfra));
    return kolumny;
}
#ifdef DEBUG
void ans(){
    random_device rd;
    mt19937_64 r(rd());
    auto spr=[&](cll n) {
        V <vi> kolumny=zakoduj(n);
        shuffle(all(kolumny), r);
        vi wierkol(10); iota(all(wierkol), 0);
        shuffle(all(wierkol), r);
        V <vi> finkol=kolumny;
        REP(i, 10)
            REP(kol, 10)
                finkol[kol][i]=kolumny[kol][wierkol[i]];
        cll wyn=odkoduj(kolumny);
        assert(wyn==n);
    };
    ci ile=10000;
    cll cap=1e14;
    REP(i, ile) {
        cll n=r()%cap+1;
        spr(n);
    }
    REP(i, ile)
        spr(i+1);
    REP(i, 100)
        REP(j, 100)
            spr(cap-i);
}
#else
void ans(){
    string imie;
    cin >> imie;
    if (imie=="Algosia") {
        cll ncap=LL(),t=I();
        REP(ti, t) {
            cll n=LL();
            V <vi> kolumny=zakoduj(n);
            REP(wier, 10) {
                REP(kol, 10)
                    print("{}", char(kolumny[kol][wier]+'0'));
                println("");
                cout.flush();
            }
        }
    }
    else {
        assert(imie=="Bajtek");
        cll ncap=LL(),t=I();
        REP(ti, t) {
            V <string> wiersze(10);
            REP(wier, 10)
                cin >> wiersze[wier];
            V <vi> kolumny(10, vi(10));
            REP(wier, 10)
                REP(kol, 10)
                    kolumny[kol][wier]=wiersze[wier][kol]=='1';
            println("{}", odkoduj(kolumny));
            cout.flush();
        }
    }
}
#endif
int main(){
    // BUHBUH.
    //ios_base::sync_with_stdio(0),cin.tie(0);
    int tt=1;
    //tt=I();
    while (tt--)ans();
}