#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;

struct pt
{
    int x,y;
    int id;
};

struct query
{
    int tp;
    int x,y;
};

const int MAXN = 100000;
int n;
query queries[MAXN+111];
pt pts[MAXN+111];
const int INF = 1000000000;

struct node
{
    bool zeroDown = false;
    int sum = 0;
    int minVal = INF;
};

bool SP(pt A,pt B)
{
    if (A.x != B.x)
        return A.x < B.x;
    else
        return A.y < B.y;
}

int MIN(int a,int b)
{
    if (a<b)
        return a;
    else
        return b;
}

int qID[MAXN+111];

int counterPart[MAXN+111];

int activeSpot[MAXN+111];

node IT[MAXN*4];
int LEAFOFFSET;

int cleverTFO[4*MAXN+111];

node bigList[MAXN*20];
int verList[MAXN*20];
int L=0;

int curDepth = 0;

inline void Change(int ver)
{
    if ( (cleverTFO[ver] & (1<<curDepth)) == 0 )
    {
        cleverTFO[ver] |= (1<<curDepth);
        L++;
        bigList[L] = IT[ver];
        verList[L] = ver;
    }
}


int decoder = 0;

inline void Refresh(int ver)
{
    if (IT[ver].zeroDown)
    {
        Change(ver);

        //if (decoder == 4123227)
        //    cout<<"entered and its "<<IT[16406].sum<<endl;

        IT[ver].sum = 0;
        IT[ver].minVal = INF;
        IT[ver].zeroDown = false;


        //if (decoder == 4123227)
        //    cout<<"midday and its "<<IT[16406].sum<<endl;

        if (ver <= LEAFOFFSET)
        {
            //if (decoder == 4123227)
            //    cout<<"lunch and its "<<IT[16406].sum<<endl;

            Change(2*ver);

            //if (decoder == 4123227)
            //    cout<<"dessert and its "<<IT[16406].sum<<endl;

            Change(2*ver+1);

            //if (decoder == 4123227)
            //    cout<<"post lunch and its "<<IT[16406].sum<<" when calling "<<2*ver+1<<endl;

            IT[2*ver].zeroDown = true;
            IT[2*ver+1].zeroDown = true;

            //if (decoder == 4123227)
            //    cout<<"afternoon and its "<<IT[16406].sum<<endl;
        }

        //if (decoder == 4123227)
        //    cout<<"exiting and its "<<IT[16406].sum<<endl;
    }

    return;
}


int leftMIN(int ver,int l,int r,int ind)
{
    //cout<<l<<"~"<<r<<endl;
    /*if (IT[16406].sum < 0)
    {
        cout<<"igga y"<<endl;
        while(1);
    }*/

    decoder++;

    /*if (decoder == 4123227)
    {
        cout<<ver<<endl;
        cout<<LEAFOFFSET<<" btw"<<endl;
        cout<<IT[16406].sum<<endl;
    }*/

    Refresh(ver);

    /*
    if (decoder == 4123227)
    {
        cout<<ver<<endl;
        cout<<IT[16406].sum<<endl;
    }

    if (IT[16406].sum < 0)
    {
        cout<<"pcti "<<decoder<<endl;
        while(1);
    }
    */

    if (ind < l)
        return INF;
    else if (ind >= r)
        return IT[ver].minVal;
    else
    {
        int mid = (l+r)/2;
        return MIN(leftMIN(2*ver,l,mid,ind), leftMIN(2*ver+1,mid+1,r,ind));
    }
}

bool addVal(int ver,int l,int r,int ind,int val)
{
    Refresh(ver);

    if (l == r)
    {
        if (l == ind)
        {
            Change(ver);

            IT[ver].minVal = val;
            IT[ver].sum = 1;

            return false;
        }
        else
        {
            if (IT[ver].minVal < val)
            {
                return true;
            }
            else
            {
                Change(ver);

                IT[ver].minVal = INF;
                IT[ver].sum = 0;

                return false;
            }
        }
    }

    int mid = (l+r)/2;
    bool ans;

    if (ind < l)
    {
        if (IT[ver].minVal > val)
        {
            Change(ver);
            IT[ver].zeroDown = true;
            Refresh(ver);

            return false;
        }
        else
        {
            ans = addVal(2*ver,l,mid,ind,val);
            if (!ans)
            {
                ans = addVal(2*ver+1,mid+1,r,ind,val);
            }
        }
    }
    else if (ind <= mid)
    {
        ans = addVal(2*ver,l,mid,ind,val);
        if (!ans)
        {
            ans = addVal(2*ver+1,mid+1,r,ind,val);
        }
    }
    else
        ans = addVal(2*ver+1,mid+1,r,ind,val);

    Refresh(2*ver);
    Refresh(2*ver+1);

    Change(ver);
    IT[ver].sum = IT[2*ver].sum + IT[2*ver+1].sum;
    IT[ver].minVal = MIN(IT[2*ver].minVal, IT[2*ver+1].minVal);

    /*if (IT[ver].sum < 0)
    {
        cout<<"noperino "<<ver<<" while adding "<<val<<" to "<<ind<<endl;

        cout<<"kids are "<<IT[2*ver].sum<<" and "<<IT[2*ver+1].sum<<endl;

        cout<<"Problem is at "<<2*ver<<" = "<<IT[2*ver].sum<<endl;

        while(1);
    }*/

    return ans;
}

void addTower(int y,int ind)
{
    /*if (IT[16406].sum < 0)
    {
        cout<<"cum?!"<<endl;
        while(1);
    }*/

    int leftVal = leftMIN(1,1,LEAFOFFSET+1,ind);

    /*if (IT[16406].sum < 0)
    {
        cout<<"de ceee"<<endl;
        while(1);
    }*/

    if (leftVal <= y)
    {
        //cout<<"towere uselese"<<endl;
        return;
    }

    /*if (IT[16406].sum < 0)
    {
        cout<<"GOING BADLY BOYOZ"<<endl;
        //while(1);
    }*/

    addVal(1,1,LEAFOFFSET+1,ind,y);

    /*if (IT[16406].sum < 0)
    {
        cout<<"GOING BADLY BOYOS"<<endl;
        while(1);
    }*/

    return;
}

int answer[MAXN+11];

void revertBack(int s)
{
    int i;

    /*if (IT[16406].sum < 0)
    {
        cout<<"no es posible"<<endl;
        while(1);
    }*/

    for (i=s+1;i<=L;i++)
    {
        IT[ verList[i] ] = bigList[i];
        cleverTFO[ verList[i] ] &= (~(1<<curDepth));
    }

    /*if (IT[16406].sum < 0)
    {
        cout<<"nu e posibil"<<endl;
        while(1);
    }*/

    return;
}

void printNode(node A)
{
    cout<<"{"<<A.zeroDown<<", "<<A.sum<<", "<<A.minVal<<"}";
}

void printTree()
{
    int i;

    for (i=1;i<=LEAFOFFSET+n;i++)
    {
        printNode(IT[i]);
        cout<<endl;
    }

    return;
}

void status(int l,int r)
{
    cout<<"STATUS OF "<<l<<"-----------------"<<r<<endl;
    printTree();
    cout<<"--------------------------"<<endl;
}

void DaQ(int l,int r)
{
    int s = L;
    int mid = (l+r)/2;
    int i;

    curDepth++;

    for (i=mid+1;i<=r;i++)
    {
        if (counterPart[i] < l)
        {
            addTower(queries[i].y, qID[i]);
        }
    }

    if (l==r)
    {
        if (counterPart[l] > l)
            addTower(queries[l].y, qID[l]);

        if (IT[1].sum < 0)
        {
            cout<<"NO at "<<l<<endl;
            while(1);
        }

        answer[l] = IT[1].sum;
    }
    else
        DaQ(l,mid);

    revertBack(s);

    L = s;

    if (l==r)
    {
        curDepth--;
        return;
    }

    for (i=l;i<=mid;i++)
    {
        if (counterPart[i] > r)
        {
            addTower(queries[i].y, qID[i]);
        }
    }

    DaQ(mid+1,r);

    revertBack(s);

    L = s;

    curDepth--;
    return;
}

int main()
{
    freopen("towers.in","r",stdin);
    freopen("towers.out","w",stdout);

    int i,j;
    int x1,y1;
    int curID = 0;

    scanf("%d",&n);
    LEAFOFFSET=1;
    while(LEAFOFFSET<n)
        LEAFOFFSET*=2;
    LEAFOFFSET--;

    for (i=1;i<=n;i++)
    {
        scanf("%d %d %d",&queries[i].tp,&queries[i].x,&queries[i].y);

        pts[i].id = i;
        pts[i].x = queries[i].x;
        pts[i].y = queries[i].y;
    }

    sort(pts+1,pts+1+n,SP);

    for (i=1;i<=n;i++)
    {
        if (i==1 || pts[i].x != pts[i-1].x || pts[i].y != pts[i-1].y)
        {
            curID++;
        }

        qID[ pts[i].id ] = curID;
    }

    for (i=1;i<=n;i++)
    {
        if (queries[i].tp == 1)
        {
            activeSpot[ qID[i] ] = i;
            counterPart[i] = n+1;
        }
        else
        {
            counterPart[i] = activeSpot[ qID[i] ];
            counterPart[ activeSpot[ qID[i] ] ] = i;
        }
    }

    DaQ(1,n);

    for (i=1;i<=n;i++)
    {
        printf("%d\n",answer[i]);

        if (i <= 5)
            fprintf(stderr,"%d\n",answer[i]);
    }

    return 0;