#ifdef NACHIA
#define _GLIBCXX_DEBUG
#else
#define NDEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(int i=0; i<int(n); i++)
const i64 INF = 1001001001001001001;
template<typename A> void chmin(A& l, const A& r){ if(r < l) l = r; }
template<typename A> void chmax(A& l, const A& r){ if(l < r) l = r; }
using namespace std;


#include <iterator>
#include <functional>
#include <utility>
#include <type_traits>

template<class Elem> struct vec;

template<class Iter>
struct seq_view{
    using Ref = typename std::iterator_traits<Iter>::reference;
    using Elem = typename std::iterator_traits<Iter>::value_type;
    Iter a, b;
    Iter begin() const { return a; }
    Iter end() const { return b; }
    int size() const { return (int)(b-a); }
    seq_view(Iter first, Iter last) : a(first), b(last) {}
    seq_view sort() const { std::sort(a, b); return *this; }
    Ref& operator[](int x) const { return *(a+x); }
    template<class F = std::less<Elem>, class ret = vec<int>> ret sorti(F f = F()) const {
        ret x(size()); for(int i=0; i<size(); i++) x[i] = i;
        x().sort([&](int l, int r){ return f(a[l],a[r]); });
        return x;
    }
    template<class ret = vec<Elem>> ret col() const { return ret(begin(), end()); }
    template<class ret = vec<Elem>> ret cumsum() const {
        auto res = ret(size() + 1, Elem(0));
        for(int i=0; i<size(); i++) res[i+1] = res[i] + operator[](i);
        return res;
    }
    template<class F = std::equal_to<Elem>, class ret = vec<std::pair<Elem, int>>>
    ret rle(F eq = F()) const {
        auto x = ret();
        for(auto& a : (*this)){
            if(x.size() == 0 || !eq(x[x.size()-1].first, a)) x.emp(a, 1); else x[x.size()-1].second++;
        } return x;
    }
    template<class F> seq_view sort(F f) const { std::sort(a, b, f); return *this; }
    Iter uni() const { return std::unique(a, b); }
    Iter lb(const Elem& x) const { return std::lower_bound(a, b, x); }
    Iter ub(const Elem& x) const { return std::upper_bound(a, b, x); }
    int lbi(const Elem& x) const { return lb(x) - a; }
    int ubi(const Elem& x) const { return ub(x) - a; }
    seq_view bound(const Elem& l, const Elem& r) const { return { lb(l), lb(r) }; }
    template<class F> Iter lb(const Elem& x, F f) const { return std::lower_bound(a, b, x, f); }
    template<class F> Iter ub(const Elem& x, F f) const { return std::upper_bound(a, b, x, f); }
    template<class F> Iter when_true_to_false(F f) const {
        if(a == b) return a;
        return std::lower_bound(a, b, *a,
            [&](const Elem& x, const Elem&){ return f(x); });
    }
    seq_view same(Elem x) const { return { lb(x), ub(x) }; }
    template<class F> auto map(F f) const {
        vec<decltype(f(std::declval<const typename Iter::value_type&>()))> r;
        for(auto& x : *this) r.emp(f(x));
        return r;
    }
    Iter max() const { return std::max_element(a, b); }
    Iter min() const { return std::min_element(a, b); }
    template<class F = std::less<Elem>>
    Iter min(F f) const { return std::min_element(a, b, f); }
    seq_view rev() const { std::reverse(a, b); return *this; }
};

template<class Elem>
struct vec {
public:
    using Base = typename std::vector<Elem>;
    using Iter = typename Base::iterator;
    using CIter = typename Base::const_iterator;
    using View = seq_view<Iter>;
    using CView = seq_view<CIter>;

    vec(){}
    explicit vec(int n, const Elem& value = Elem()) : a(0<n?n:0, value) {}
    template <class I2> vec(I2 first, I2 last) : a(first, last) {}
    vec(std::initializer_list<Elem> il) : a(std::move(il)) {}
    vec(Base b) : a(std::move(b)) {}
    operator Base() const { return a; }

    Iter begin(){ return a.begin(); }
    CIter begin() const { return a.begin(); }
    Iter end(){ return a.end(); }
    CIter end() const { return a.end(); }
    int size() const { return a.size(); }
    bool empty() const { return a.empty(); }
    Elem& back(){ return a.back(); }
    const Elem& back() const { return a.back(); }
    vec& sortuni(){ (*this)().sort(); a.erase((*this)().uni(), end()); return *this; }
    vec sortunied(){ vec x = *this; x.sortuni(); return x; }
    Iter operator()(int x){ return a.begin() + x; }
    CIter operator()(int x) const { return a.begin() + x; }
    View operator()(int l, int r){ return { (*this)(l), (*this)(r) }; }
    CView operator()(int l, int r) const { return { (*this)(l), (*this)(r) }; }
    View operator()(){ return (*this)(0,size()); }
    CView operator()() const { return (*this)(0,size()); }
    Elem& operator[](int x){ return a[x]; }
    const Elem& operator[](int x) const { return a[x]; }
    Base& operator*(){ return a; }
    const Base& operator*() const { return a; }
    vec& push(Elem args){
        a.push_back(std::move(args));
        return *this;
    }
    template<class... Args>
    vec& emp(Args &&... args){
        a.emplace_back(std::forward<Args>(args) ...);
        return *this;
    }
    template<class Range>
    vec& app(Range& x){ for(auto& v : x){ emp(v); } return *this; }
    Elem pop(){ Elem x = std::move(a.back()); a.pop_back(); return x; }
    void resize(int sz){ a.resize(sz); }
    void reserve(int sz){ a.reserve(sz); }
    bool operator==(const vec& r) const { return a == r.a; }
    bool operator!=(const vec& r) const { return a != r.a; }
    bool operator<(const vec& r) const { return a < r.a; }
    bool operator<=(const vec& r) const { return a <= r.a; }
    bool operator>(const vec& r) const { return a > r.a; }
    bool operator>=(const vec& r) const { return a >= r.a; }
    vec<vec<Elem>> pile(int n) const { return vec<vec<Elem>>(n, *this); }
    template<class F> vec& filter(F f){
        int p = 0;
        for(auto& x : a) if(f(x)) std::swap(a[p++],x);
        resize(p); return *this;
    }
    vec& operator+=(const vec& r){ return app(r); }
    vec operator+(const vec& r) const { vec x = *this; x += r; return x; }
    vec operator*(int t) const { vec res; while(t--){ res += *this; } return res; }
private: Base a;
};

template<class IStr, class U, class T>
IStr& operator>>(IStr& is, vec<std::pair<U,T>>& v){ for(auto& x:v){ is >> x.first >> x.second; } return is; }
template<class IStr, class T>
IStr& operator>>(IStr& is, vec<T>& v){ for(auto& x:v){ is >> x; } return is; }
template<class OStr, class T>
OStr& operator<<(OStr& os, const vec<T>& v){
    for(int i=0; i<v.size(); i++){
        if(i){ os << ' '; } os << v[i];
    } return os;
}
template<class OStr, class U, class T>
OStr& operator<<(OStr& os, const vec<std::pair<U,T>>& v){
    for(int i=0; i<v.size(); i++){
        if(i){ os << ' '; } os << '(' << v[i].first << ',' << v[i].second << ')';
    } return os;
}

namespace nachia {

template<
    class S, class F,
    S op(S,S), S e(), void reverseprod(S&),
    S mapping(F,S), F composition(F,F), F id()
>
struct LinkCutTreeRootedAggregation {

    struct Node {
        Node* l = 0, * r = 0, * p = 0;
        S a = e();
        S prod = e();
        F f = id();
        // lazy & 1 : reverse
        // lazy & 2 : deta
        int lazy = 0;
        
        void prepareDown() {
            if(lazy & 2){
                if(l) {
                    l->a = mapping(f, l->a);
                    l->prod = mapping(f, l->prod);
                    l->f = composition(f, l->f);
                    l->lazy |= 2;
                }
                if(r) {
                    r->a = mapping(f, r->a);
                    r->prod = mapping(f, r->prod);
                    r->f = composition(f, r->f);
                    r->lazy |= 2;
                }
                f = id();
            }
            if (lazy & 1) {
                std::swap(l, r);
                if (l) { l->lazy ^= 1; reverseprod(l->prod); }
                if (r) { r->lazy ^= 1; reverseprod(r->prod); }
            }
            lazy = 0;
        }
        void prepareUp() {
            auto res = a;
            if(l) res = op(l->prod, res);
            if(r) res = op(res, r->prod);
            prod = res;
        }
        Node** p_parentchild() {
            if(!p) return nullptr;
            if(p->l == this) return &p->l;
            else if(p->r == this) return &p->r;
            return nullptr;
        }
        void rotL() {
            Node* t = p;
            Node** parentchild_p = t->p_parentchild();
            if(parentchild_p){ *parentchild_p = this; }
            p = t->p;
            t->p = this;
            t->r = l;
            if(l) l->p = t;
            l = t;
        }
        void rotR() {
            Node* t = p;
            Node** parentchild_p = t->p_parentchild();
            if(parentchild_p){ *parentchild_p = this; }
            p = t->p;
            t->p = this;
            t->l = r;
            if(r) r->p = t;
            r = t;
        }
    };

    std::vector<Node> A;
    LinkCutTreeRootedAggregation(int n = 0) {
        A.resize(n);
    }
    LinkCutTreeRootedAggregation(const std::vector<S>& a)
        : LinkCutTreeRootedAggregation(a.size())
    {
        for (int i = 0; i < (int)a.size(); i++) A[i].prod = A[i].a = a[i];
    }
    Node* at(int idx) {
        return &A[idx];
    }
    void splay(Node* c) {
        c->prepareDown();
        while(true) {
            Node* p = c->p;
            if(!p) break;
            Node* pp = p->p;
            if(pp) pp->prepareDown();
            p->prepareDown();
            c->prepareDown();
            if(p->l == c){
                if(!pp){ c->rotR(); }
                else if(pp->l == p){ p->rotR(); c->rotR(); }
                else if(pp->r == p){ c->rotR(); c->rotL(); }
                else{ c->rotR(); }
            }
            else if(p->r == c){
                if(!pp){ c->rotL(); }
                else if(pp->r == p){ p->rotL(); c->rotL(); }
                else if(pp->l == p){ c->rotL(); c->rotR(); }
                else{ c->rotL(); }
            }
            else break;
            if(pp) pp->prepareUp();
            p->prepareUp();
        }
        c->prepareUp();
    }
    void expose(Node* c) {
        auto p = c;
        while(p){ splay(p); p = p->p; }
        p = c;
        while(p->p){ p->p->r = p; p = p->p; }
        splay(c);
        c->r = nullptr;
        c->prod = (c->l ? op(c->l->prod, c->a) : c->a);
    }
    void link(Node* c, Node* r) {
        if(c == r) return;
        expose(c);
        expose(r);
        if(c->p) return;
        c->p = r;
    }
    void cut(Node* c) {
        expose(c);
        if(!c->l) return;
        c->l->p = nullptr;
        c->l = nullptr;
    }
    S get(Node* p) {
        expose(p);
        return p->a;
    }
    void set(Node* p, S x) {
        expose(p);
        p->a = x;
        p->prepareUp();
    }
    void apply(Node* p, F f){
        expose(p);
        p->a = mapping(f, p->a);
        p->prod = mapping(f, p->prod);
        p->f = f;
        p->lazy |= 2;
        p->prepareDown();
    }
};

} // namespace nachia

namespace nachia{

template<
    class S,
    S op(S l, S r)
>
struct Segtree {
private:
    int N;
    std::vector<S> A;
    int xN;

    void mergev(int i){
        if(i < N) A[i] = op(A[i*2], A[i*2+1]);
    }

    template<class E>
    int minLeft2(int r, E cmp, int a = 0, int b = 0, int i = -1) const {
        static S x;
        if(i == -1){ a=0; b=N; i=1; x=A[0]; }
        if(r <= a) return a;
        if(b <= r){
            S nx = op(A[i], x);
            if(cmp(nx)){ x = nx; return a; }
        }
        if(b - a == 1) return b;
        int q = minLeft2(r, cmp, (a+b)/2, b, i*2+1);
        if(q > (a+b)/2) return q;
        return minLeft2(r, cmp, a, (a+b)/2, i*2);
    }
    
    template<class E>
    int maxRight2(int l, E cmp, int a = 0, int b = 0, int i = -1) const {
        static S x;
        if(i == -1){ a=0; b=N; i=1; x=A[0]; }
        if(b <= l) return b;
        if(l <= a){
            S nx = op(x, A[i]);
            if(cmp(nx)){ x = nx; return b; }
        }
        if(b - a == 1) return a;
        int q = maxRight2(l, cmp, a, (a+b)/2, i*2);
        if(q < (a+b)/2) return q;
        return maxRight2(l, cmp, (a+b)/2, b, i*2+1);
    }

public:
    Segtree() : N(0) {}
    Segtree(int n, S e) : xN(n) {
        N = 1; while (N < n) N *= 2;
        A.assign(N * 2, e);
    }
    Segtree(const std::vector<S>& a, S e) : Segtree(a.size(), e){
        for(int i=0; i<(int)a.size(); i++) A[i + N] = a[i];
        for(int i=N-1; i>=1; i--) mergev(i);
    }

    S getE() const { return A[0]; }

    void set(int p, S x){
        p += N; A[p] = x;
        for(int d=1; (1<<d)<=N; d++) mergev(p>>d);
    }

    S get(int p) const { return A[N+p]; }

    S prod(int l, int r) const {
        l += N; r += N;
        S ql = A[0], qr = A[0];
        while(l<r){
            if(l&1) ql = op(ql, A[l++]);
            if(r&1) qr = op(A[--r], qr);
            l /= 2;
            r /= 2;
        }
        return op(ql, qr);
    }

    S allProd() const { return A[1]; }

    // bool cmp(S)
    template<class E>
    int minLeft(int r, E cmp) const {
        return minLeft2(r, cmp);
    }

    // bool cmp(S)
    template<class E>
    int maxRight(int l, E cmp) const {
        int x = maxRight2(l, cmp);
        return x > xN ? xN : x;
    }
};

} // namespace nachia

namespace nachia {
    template<class T, class Cmp = std::less<T>>
    struct PointSetRangeMin{
    private:
        static T minop(T l, T r){ return std::min(l, r, Cmp()); }
        using Base = Segtree<T, minop>;
        Base base;
        Cmp cmpx;
    public:
        PointSetRangeMin() {}
        PointSetRangeMin(int len, T INF)
            : base(len, INF){}
        PointSetRangeMin(const std::vector<T>& init, T INF)
            : base(init, INF){}
        T min(int l, int r){ return base.prod(l, r); }
        T min(){ return base.allProd(); }
        void set(int pos, T val){ base.set(pos, val); }
        T getinf() const { return base.getE(); }
        void setinf(int pos){ set(pos, getinf()); }
        T get(int pos){ return base.get(pos); }
        void chmin(int pos, T val){ base.set(pos, minop(get(pos), val)); }
        int lBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return cmpx(val, x); }); }
        int uBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return !cmpx(x, val); }); }
        int lBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return cmpx(val, x); }); }
        int uBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return !cmpx(x, val); }); }
        template<class E>
        int minLeft(int r, E cmp){ return base.minLeft(r, cmp); }
        template<class E>
        int maxRight(int l, E cmp){ return base.maxRight(l, cmp); }
        int argmin(int l, int r){
            auto v = this->min(l, r);
            if(!cmpx(v, getinf())) return -1;
            return lBoundRight(l, v);
        }
    };
} // namespace nachia

namespace LCT {
    struct S {
        pair<i64,i64> V;
        i64 D;
    };
    static S op(S l, S r) { return {min(l.V,r.V),max(l.D,r.D)}; }
    static S e() { return { { INF, -1 }, -1 }; }
    static void reverseprod(S& x) {}
    using F = i64;
    static S mapping(F f, S x) { return { { f + x.V.first, x.V.second }, x.D }; }
    static F composition(F f, F x) { return f + x; }
    static F id() { return 0; }
    using Ds = nachia::LinkCutTreeRootedAggregation<S,F,op,e,reverseprod,mapping,composition,id>;
}

void testcase(){
    i64 Q; cin >> Q;
    struct User { i64 i; i64 o; i64 k; };
    vec<User> I;
    struct Query { i64 l; i64 t; i64 i; };
    vec<Query> queries;
    vec<i64> lastin(Q);
    rep(qi,Q){
        i64 t; cin >> t;
        if(t == 1){
            i64 k; cin >> k;
            I.push({ qi, -1, k });
        } else if(t == 2){
            i64 u; cin >> u; u--;
            I[u].o = qi;
        } else {
            i64 l; cin >> l;
            queries.push({ l, qi, queries.size() });
        }
        lastin[qi] = I.size() - 1;
    }
    rep(i,queries.size()) queries[i].i = i;
    sort(queries.begin(), queries.end(), [](Query l, Query r){ return l.l < r.l; });
    queries().rev();

    for(auto& i : I) if(i.o == -1) i.o = Q;
    auto ds = nachia::PointSetRangeMin<i64>(Q+1, INF);
    i64 unum = I.size();
    rep(x,unum){
        auto [i,o,k] = I[x];
        ds.set(i, x);
    }
    ds.set(Q, unum);
    //rep(i,Q+1) cout << ds.get(i) << " ";
    //cout << endl;
    //for(auto [i,o,k] : I) cout << i << " " << o << " " << k << endl;

    auto head = [&](i64 p = 0) -> i64 {
        return ds.get(ds.lBoundRight(p, INF/2));
    };

    auto lc = LCT::Ds(unum+1);
    //auto lct = nachia::LinkCutTree(unum+1);
    rep(i,unum) lc.set(lc.at(i), {{ I[i].k, i }, i });
    lc.set(lc.at(unum), {{ INF, unum }, -1});
    rep(i,unum){
        i64 h = head(I[i].o);
        //cout << "i = " << i << " , h = " << h << endl;
        lc.link(lc.at(i), lc.at(h));
    }

    i64 msgcnt = 0;
    vec<i64> ans(queries.size(), -1);

    //cout << "##" << endl;

    auto search_last_write = [&](LCT::Ds::Node* v, i64 time) -> i64 {
        if(v->prod.D <= time) return v->prod.D;
        auto orig = v;
        i64 res = -1;
        while(true){
            v->prepareDown();
            if(v->r){
                if(time < v->r->prod.D){ v = v->r; continue; }
                chmax(res, v->r->prod.D);
            }
            if(time < v->a.D) break;
            chmax(res, v->a.D);
            if(v->l){
                //cout << "v->l->prod.D = " << v->l->prod.D << endl;
                if(time < v->l->prod.D){ v = v->l; continue; }
                chmax(res, v->l->prod.D);
            }
            break;
        }
        lc.expose(v);
        lc.expose(orig);
        return res;
    };

    //auto dump = [&](auto& rec, LCT::Ds::Node* v) -> void {
    //    if(v->l) rec(rec, v->l);
    //    if(v->a.D >= 0) cout << " " << v->a.D;
    //    if(v->r) rec(rec, v->r);
    //};
    
    rep(tttt,unum){
        //rep(i,Q+1){ cout << ds.get(i) << " "; } cout << endl;
        i64 h = head(0);
        if(h == unum) break;
        lc.expose(lc.at(h));

        auto [new_comments, x] = lc.at(h)->prod.V;
        msgcnt += new_comments;
        //cout << "new_comments = " << new_comments << " , to_erase = " << x << endl;
        
        //cout << "writer : "; dump(dump, lc.at(h)); cout << endl;

        while(queries.size() && queries.back().l <= msgcnt){
            lc.expose(lc.at(h));
            auto [l,t,i] = queries.pop();
            //cout << "l = " << l << " , t = " << t << " , i = " << i << " , lastin = " << lastin[t] << endl;
            auto lastValid = search_last_write(lc.at(h), lastin[t]);
            //cout << "i = " << i << " , h = " << h << " , lastValid = " << lastValid << endl;
            if(lastValid != -1 && t < I[lastValid].o) ans[i] = lastValid;
        }

        //cout << "h = " << h << endl;
        lc.expose(lc.at(h));
        lc.apply(lc.at(h), -new_comments);
        auto xval = lc.get(lc.at(x));
        lc.set(lc.at(x), { { INF, xval.V.second }, -1 });

        lc.cut(lc.at(x));
        lc.link(lc.at(x), lc.at(x+1));

        ds.set(I[x].i, INF);
    }

    for(auto a : ans) cout << (a+1) << '\n';
}

int main(){
    ios::sync_with_stdio(false); cin.tie(nullptr);
    testcase();
    return 0;
}