#include <iostream>

using namespace std;

template<class T>
class my_vector {
 public:
  my_vector(const size_t new_capacity = 100) {
    capacity = new_capacity;
    arr_size = 0;
    m = new T[new_capacity];
  }

  void push_back(const T x) {
    if (arr_size < capacity) {
      m[arr_size] = x;
      arr_size++;
    } else {
      resize(capacity * (size_t) 2);
      m[arr_size] = x;
      arr_size++;
    }
  }

  int pop_back() {
    if (arr_size <= capacity / 4) {
      resize(capacity / (size_t) 2);
    }
    arr_size--;
    return m[arr_size];
  }

  size_t size() const {
    return arr_size;
  }

  T &operator[](const int index) {
    return m[index];
  }

 private:
  T *m;
  size_t arr_size;
  size_t capacity;

  void resize(size_t new_capacity) {
    T *p = m;
    capacity = new_capacity;
    m = new T[capacity];
    for (size_t i = 0; i < arr_size; ++i) {
      m[i] = p[i];
    }
    delete[] p;
  }
};

template<class T>
class my_stack {
 public:
  bool empty() const {
    return s.size() == 0;
  }

  void push(T x) {
    s.push_back(x);
  }

  T pop() {
    return s.pop_back();
  }

 private:
  my_vector<T> s = my_vector<T>(10);
};

int main() {
  my_stack<int> stack;
  int M;
  cin >> M;
  for (int i = 0; i < M; ++i) {
    char action;
    cin >> action;
    if (action == '-') {
      cout << stack.pop() << endl;
    } else if (action == '+') {
      int N;
      cin >> N;
      stack.push(N);
    }
  }
  return 0;
}