#include <algorithm>
#include <iostream>
#include <limits>
#include <vector>


class Stack {
public:
    bool empty() const {
        return stack_.empty();
    }

    void push(int element) {
        if (stack_.empty()) {
            stack_.emplace_back(element, element);
        } else {
            stack_.emplace_back(element, std::min(element, stack_.back().current_min));
        }
    }

    void pop() {
        stack_.pop_back();
    }

    int back() const {
        return stack_.back().value;
    }

    int get_min() const {
        if (stack_.empty()) {
            return std::numeric_limits<int>::max();
        }
        return stack_.back().current_min;
    }

private:
    struct Item {
        int value;
        int current_min;

        Item(int value, int current_min)
            : value(value), current_min(current_min) {}
    };

    std::vector<Item> stack_;
};

class Queue {
public:
    bool empty() const {
        return s_1_.empty() && s_2_.empty();
    }

    void push(int element) {
        s_1_.push(element);
    }

    int pop() {
        if (s_2_.empty()) {
            while (!s_1_.empty()) {
                s_2_.push(s_1_.back());
                s_1_.pop();
            }
        }
        int back = s_2_.back();
        s_2_.pop();
        return back;
    }

    int get_min() const {
        return std::min(s_1_.get_min(), s_2_.get_min());
    }

private:
    Stack s_1_;
    Stack s_2_;
};

int main() {
    Queue queue;
    int numbers_amount, num;
    std::cin >> numbers_amount;
    for (int i = 0; i < numbers_amount; ++i) {
        std::cin >> num;
        if (num == 0) {
            if (queue.empty()) {
                std::cout << -1 << std::endl;
            } else {
                std::cout << queue.get_min() << std::endl;
                queue.pop();
            }
        } else {
            queue.push(num);
        }
    }
    return 0;
}