#include <fstream>
#include <cstdint>
#include <string>
#include <map>

using namespace std;

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

const int_fast32_t NMAX = 100000;

struct BigNum
{
    string val;
    bool operator < (const BigNum& x) const
    {
        if(val.size() != x.val.size())
            return val.size() < x.val.size();
        return val < x.val;
    }
};

map<BigNum, int_fast32_t> M;
BigNum vec[NMAX + 1];
int_fast32_t freq[NMAX + 1];
int_fast32_t n, m;

struct Query
{
    bool t;
    BigNum num;
    int_fast32_t k;
};
Query queries[NMAX + 1];

class SegmentTree
{
private:
    int_fast32_t tree[NMAX << 2 | 1];
    void Update(int_fast32_t nod, int_fast32_t st, int_fast32_t dr, int_fast32_t pos, int_fast32_t x)
    {
        if(st == dr)
        {
            tree[nod] = x;
            return;
        }
        int_fast32_t mid = st + ((dr - st) >> 1);
        if(pos <= mid)
            Update(nod << 1, st, mid, pos, x);
        else
            Update(nod << 1 | 1, mid + 1, dr, pos, x);
        tree[nod] = tree[nod << 1] + tree[nod << 1 | 1];
    }
    int_fast32_t Query(int_fast32_t nod, int_fast32_t st, int_fast32_t dr, int_fast32_t qst, int_fast32_t qdr)
    {
        if(qdr < st || dr < qst)
            return 0;
        if(qst <= st && dr <= qdr)
            return tree[nod];
        int_fast32_t mid = st + ((dr - st) >> 1);
        return Query(nod << 1, st, mid, qst, qdr) +
               Query(nod << 1 | 1, mid + 1, dr, qst, qdr);
    }
    int_fast32_t Walk(int_fast32_t nod, int_fast32_t st, int_fast32_t dr, int_fast32_t k, int_fast32_t pref)
    {
        if(st == dr)
            return st;
        int_fast32_t mid = st + ((dr - st) >> 1),
            sum = pref + tree[nod << 1];
        if(sum >= k)
            return Walk(nod << 1, st, mid, k, pref);
        return Walk(nod << 1 | 1, mid + 1, dr, k, sum);
    }
public:
    void Update(int_fast32_t pos, int_fast32_t x) { Update(1, 1, m, pos, x); }
    int_fast32_t Query(int_fast32_t qst, int_fast32_t qdr) { return Query(1, 1, m, qst, qdr); }
    int_fast32_t Walk(int_fast32_t k) { return Walk(1, 1, m, k, 0); }
};
SegmentTree segtree;

void ReadNums()
{
    f >> n;
    for(int_fast32_t i = 1; i <= n; i++)
    {
        f >> queries[i].t;
        if(queries[i].t == 0)
            f >> queries[i].k;
        else
        {
            f >> queries[i].num.val;
            M[queries[i].num] = 1;
        }
    }
}

void CoordCompress()
{
    m = 0;
    for(auto& [num, val] : M)
    {
        vec[++m] = num;
        val = m;
    }
}

void AnswerQueries()
{
    for(int_fast32_t i = 1; i <= n; i++)
    {
        if(queries[i].t == 0)
            g << vec[segtree.Walk(queries[i].k)].val << '\n';
        else
        {
            int_fast32_t idx = M[queries[i].num];
            if(freq[idx] == 0)
            {
                freq[idx] = 1;
                segtree.Update(idx, 1);
            }
        }
    }
}

int main()
{
    ReadNums();
    CoordCompress();
    AnswerQueries();
    f.close();
    g.close();
    return 0;
}