#include <iostream>
#include <fstream>
#include <string>

using std::string;
using std::ifstream;
using std::ofstream;

#define aibSize 131072
#define Nadejde 100000

typedef struct {
  int pos, order;
  string s;
} cell;

typedef struct {
  string s;
  int init;
} pair;

int N;
cell query[Nadejde];

int aib[aibSize + 1];
char seen[Nadejde + 1];

int size;
pair sorted[Nadejde];

int cmp(const pair &X, const pair &Y) {
  if (X.s.size() == Y.s.size()) {
    return X.s < Y.s;
  } else {
    return X.s.size() < Y.s.size();
  }
}

void sort(int begin, int end) {
  int b = begin, e = end;
  pair tmp, pivot = sorted[(b + e) >> 1];

  while (b <= e) {
    while (cmp(sorted[b], pivot)) {
      b++;
    }
    while (cmp(pivot, sorted[e])) {
      e--;
    }
    if (b <= e) {
      tmp = sorted[b];
      sorted[b++] = sorted[e];
      sorted[e--] = tmp;
    }
  }
  if (begin < e) {
    sort(begin, e);
  }
  if (b < end) {
    sort(b, end);
  }
}

void normalize() {
  int i = 0, j;

  sort(0, size - 1);
  while (i < size) {
    j = i;
    while ((j < N) && (sorted[i].s.compare(sorted[j].s) == 0)) {
      query[sorted[j].init].order = i + 1;
      j++;
    }
    i = j;
  }
}

void add(int x) {
  do {
    aib[x]++;
    x += x & -x;
  } while (x <= aibSize);
}

int bSearch(int val) {
  int x = 0, interval = aibSize >> 1;

  while (interval) {
    if (aib[x + interval] < val) {
      val -= aib[x += interval];
    }
    interval >>= 1;
  }
  return x + 1;
}

int main(void) {
  int i, task, loc;
  ifstream in("nums.in");

  in >> N;
  for (i = 0; i < N; i++) {
    in >> task;
    if (task == 1) {
      in >> query[i].s;
      sorted[size].s = query[i].s;
      sorted[size++].init = i;
      query[i].pos = task;
    } else {
      in >> query[i].pos;
      query[i].pos <<= 1;
    }
  }
  in.close();

  normalize();

  for (i = 0; i < N; i++) {
    fprintf(stderr, "%d -> %d\n", query[i].pos & 1, query[i].order);
  }

  ofstream out("nums.out");
  for (i = 0; i < N; i++) {
    task = query[i].pos & 1;
    if (task == 1) {
      loc = query[i].order;
      if (!seen[loc]) {
        seen[loc] = 1;
        add(loc);
      }
    } else {
      loc = bSearch(query[i].pos >> 1);
      out << sorted[loc - 1].s << "\n";
    }
  }
  out.close();

  /// Multumim Doamne!
  puts("Doamne ajuta!");
  return 0;
}