#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>

using namespace std;

const int maxn = 100001;

ifstream in("nums.in");
ofstream out("nums.out");

struct info
{
    string nr;
    int poz;
};

int compare(const string &x, const string &y)
{
    if ( x.size() < y.size() ) return 1;
    else if ( x.size() > y.size() ) return 0;
    else
    {
        for ( unsigned int i = 0; i < x.size(); ++i )
            if ( x[i] < y[i] )
                return 1;
            else if ( x[i] > y[i] )
                return 0;
    }

    return -110;
}

bool operator <(const info &x, const info &y)
{
    int t = compare(x.nr, y.nr);
    if ( t == -110 )
        return x.poz < y.poz;
    else
        return t;
}

int n, k;
int poz_in_sorted[maxn];
int dupp[maxn];
char all[maxn]; // toate datele de intrare
vector <info> numbers; // numai numerele
int queries[maxn];

string temp[maxn];

int arb[1 << 18];

void read()
{
    in >> n;

    info tmp;

    numbers.push_back(tmp);

    for ( int i = 1; i <= n; ++i )
    {
        in >> tmp.poz;
        all[i] = tmp.poz;
        if ( tmp.poz == 0 )
            in >> queries[i];
        else if ( tmp.poz == 1 )
        {
            in >> tmp.nr;
            tmp.poz = ++k;
            numbers.push_back(tmp);
        }
    }

    in.close();

    std::sort(numbers.begin()+1, numbers.end());

    poz_in_sorted[ numbers[1].poz ] = 1;
    for ( int i = 2; i <= k; ++i )
    {
        if ( numbers[i].nr == numbers[i-1].nr )
            dupp[ numbers[i].poz ] = 1;

        poz_in_sorted[ numbers[i].poz ] = i;
    }
}

#define left (2*nod)
#define right (left+1)
#define mij ((st + dr) / 2)

void update(int nod, int st, int dr, int what)
{
    if ( what < st || what > dr ) return;

    if ( st == dr )
    {
        ++arb[nod];

        return;
    }

    update(left, st, mij, what);
    update(right, mij+1, dr, what);

    arb[nod] = arb[left] + arb[right];
}

int query(int nod, int st, int dr, int poz)
{
    if ( st == dr )
        return st;

    if ( arb[left] < poz )  return query(right, mij+1, dr, poz - arb[left]);
    else                    return query(left, st, mij, poz);
}

int main()
{
    read();

    int p = 0;
    for ( int i = 1; i <= n; ++i )
    {
        if ( all[i] == 1 )
        {
            ++p;
            if ( !dupp[p] )
                update(1, 1, k, poz_in_sorted[p]);
        }
        else
            out << numbers[query(1, 1, k, queries[i])].nr << endl;
    }

    return 0;
}