#include <bits/stdc++.h>

using namespace std;

const int N_MAX = 100002;
const int L_MAX = 100002;

int n;

string str[N_MAX];

struct TrieNode
{
    map <int, TrieNode*> sons;
    int index;
    int subSize;
    TrieNode ()
    {
        this->sons.clear();
        this->index = 0;
        this->subSize = 0;
    }
};

TrieNode* roots[L_MAX];

bool TrieInsert (TrieNode* node, char* str, int index)
{
    if(str[0] == '\0')
    {
        if(node->index == 0)
        {
            node->index = index;
            node->subSize++;
            return true;
        }
        return false;
    }
    if(node->sons.find(str[0] - '0') == node->sons.end())
        node->sons[str[0] - '0'] = new TrieNode();
    if(TrieInsert(node->sons[str[0] - '0'], str + 1, index) == true)
    {
        node->subSize++;
        return true;
    }
    return false;
}

int TrieFind (TrieNode* node, int k)
{
    if(k == 1 && node->index != 0)
        return node->index;
    for(int i = 0; i <= 9; i++)
        if(node->sons.find(i) != node->sons.end())
        {
            if(k <= node->sons[i]->subSize)
                return TrieFind(node->sons[i], k);
            k -= node->sons[i]->subSize;
        }
    return 0;
}

int BIT[L_MAX];

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

int BITquery (int pos)
{
    int ans = 0;
    for(int i = pos; i >= 1; i -= i & -i)
        ans += BIT[i];
    return ans;
}

int BITqueryCnt (int cnt)
{
    int ans = 0;
    for(int step = 16; step >= 0; step--)
        if(ans + (1 << step) <= 100000 && BIT[ans + (1 << step)] < cnt)
        {
            ans += (1 << step);
            cnt -= BIT[ans];
        }
    ans++;
    return ans;
}

int query (int k)
{
    int rootIndex = BITqueryCnt(k);
    return TrieFind(roots[rootIndex], k - BITquery(rootIndex - 1));
}

char aux[L_MAX];

int main()
{
    ifstream fin ("nums.in");
    ofstream fout ("nums.out");
    fin >> n;
    for(int i = 1; i <= 100000; i++)
        roots[i] = new TrieNode();
    for(int i = 1; i <= n; i++)
    {
        bool op;
        fin >> op;
        if(op == 0)
        {
            int k;
            fin >> k;
            fout << str[query(k)] << "\n";
        }
        else
        {
            fin >> str[i];
            for(int j = 0; j < (int)str[i].size(); j++)
                aux[j] = str[i][j];
            aux[str[i].size()] = '\0';
            if(TrieInsert(roots[str[i].size()], aux, i))
                BITupdate((int)str[i].size());
        }
    }
    return 0;
}