#include <bits/stdc++.h>

using namespace std;

const int N_MAX = 100002;

int n;

int op[N_MAX];
int ind[N_MAX];

struct Number
{
    string str;
    int index;
    int nval;
};

bool operator < (const Number &a, const Number &b)
{
    return a.index < b.index;
}

Number vnum[N_MAX];
int cntnum;

struct Query
{
    int k;
    int index;
};

Query vq[N_MAX];
int cntq;

int cnt[10];

Number aux[N_MAX];

void radix (Number v[], int lgv, int pos)
{
    for(int i = 0; i <= 9; i++)
        cnt[i] = 0;
    for(int i = 1; i <= lgv; i++)
    {
        int d = 0;
        if(pos < v[i].str.size())
            d = v[i].str[pos] - '0';
        if(d + 1 <= 9)
            cnt[d + 1]++;
    }
    for(int i = 1; i <= 9; i++)
        cnt[i] += cnt[i - 1];
    for(int i = 1; i <= lgv; i++)
    {
        int d = 0;
        if(pos < v[i].str.size())
            d = v[i].str[pos] - '0';
        aux[++cnt[d]] = v[i];
    }
    for(int i = 1; i <= lgv; i++)
        v[i] = aux[i];
}

void radixSort (Number v[], int lgv, int cntd)
{
    for(int i = 0; i < cntd; i++)
        radix(v, lgv, i);
}

vector <Number> vd[N_MAX];
Number auxv[N_MAX];

string vsort[N_MAX];

int BIT[N_MAX];

void update (int pos)
{
    for(int i = pos; i <= n; i += i & -i)
        BIT[i]++;
}

int query (int k)
{
    int ans = 0;
    for(int step = 19; step >= 0; step--)
        if(ans + (1 << step) <= n && BIT[ans + (1 << step)] < k)
        {
            ans += (1 << step);
            k -= BIT[ans];
        }
    return ans + 1;
}

int main()
{
    ifstream fin ("nums.in");
    ofstream fout ("nums.out");
    fin >> n;
    int mx = 0;
    for(int i = 1; i <= n; i++)
    {
        fin >> op[i];
        if(op[i] == 0)
        {
            ind[i] = ++cntq;
            fin >> vq[cntq].k;
            vq[cntq].index = i;
        }
        else
        {
            ind[i] = ++cntnum;
            fin >> vnum[cntnum].str;
            reverse(vnum[cntnum].str.begin(), vnum[cntnum].str.end());
            vnum[cntnum].index = i;
            vd[(int)vnum[cntnum].str.size()].push_back(vnum[cntnum]);
            mx = max(mx, (int)vnum[cntnum].str.size());
        }
    }
    int ind = 0;
    for(int i = 1; i <= mx; i++)
    {
        int lgauxv = 0;
        for(Number j : vd[i])
            auxv[++lgauxv] = j;
        radixSort(auxv, lgauxv, i);
        for(int j = ind + 1; j <= ind + lgauxv; j++)
            vnum[j] = auxv[j - ind];
        ind += lgauxv;
    }
    for(int i = 1; i <= cntnum; i++)
    {
        vsort[i] = vnum[i].str;
        reverse(vsort[i].begin(), vsort[i].end());
        vnum[i].nval = i;
    }
    sort(vnum + 1, vnum + cntnum + 1);
    int pos = 0;
    for(int i = 1; i <= cntq; i++)
    {
        while(pos < cntnum && vnum[pos + 1].index <= vq[i].index)
        {
            pos++;
            update(vnum[pos].nval);
        }
        fout << vsort[query(vq[i].k)] << "\n";
    }
    return 0;
}