#include<bits/stdc++.h>

namespace Lemuen_Daily
{
    #define endl '\n'
	#define il inline
    #define ll long long
    #define ldb long double
    #define Croll(i,l,r) for(int i=l;i<=r;++i)
    #define Troll(i,l,r) for(int i=l;i>=r;--i)
    #define cerr_time std::cerr<<(double)clock()/CLOCKS_PER_SEC
    
    const int maxn=10170000;
    const ll inf=0x7f7f7f7f7f;
    
    il int read()
    {
        int f=1,x=0;char w=getchar();
        while(w<'0'||w>'9')
        {if(w=='-')f=-1;w=getchar();}
        while(w>='0'&&w<='9')
        {x=(x<<3)+(x<<1)+(w^48);w=getchar();}
        return f*x;
    }
}using namespace Lemuen_Daily;

ll ans1,ans2;

namespace Lemuen_FHQ
{
    #define ls tr[k].son[0]
    #define rs tr[k].son[1]
    std::mt19937 rnd(time(0));

    int root,tot;
    struct star
    {
        int siz;
        int son[2];
        ll w,rd;
    }tr[maxn];
    int butf[maxn];//漂亮值

    int merge(int,int);
    void split(int,int,int&,int&);
    void split_BS(int,int,int&,int&);
    void pushup(int);
    void add(int,int);
    void del(int);
    int find_n(int,int);

    bool judge(int C)
    {
        int lrt,rrt,k;
        split(root,C,lrt,rrt);
        split(lrt,C-1,lrt,k);
        if(tr[k].siz!=0)
        {
            root=merge(merge(lrt,k),rrt);
            return 0;
        }
        else
        {
            root=merge(merge(lrt,k),rrt);
            return 1;
        }
    }

    void dfs(int k)
    {
        if(!k)return;

        ans1+=butf[k];
        ans2+=tr[k].w;

        dfs(ls);dfs(rs);
    }

    void ACT1()
    {
        int W=read(),C=read();
        if(judge(C))add(C,W);
    }
    void ACT2()
    {
        int size=tr[root].siz,rtt;
        if(!size)return;
        split_BS(root,size-1,root,rtt);
    }
    void ACT3()
    {
        int siz=tr[root].siz,rtt;
        if(!siz)return;
        split_BS(root,1,rtt,root);
    }
}

void DEBUG()
{
    using namespace Lemuen_FHQ;
    std::cout<<tr[root].siz<<endl;
}

int main()
{
    int act;
    while((act=read())!=-1)
    {
        if(act==1)
            Lemuen_FHQ::ACT1();
        else if(act==2)
            Lemuen_FHQ::ACT2();
        else if(act==3)
            Lemuen_FHQ::ACT3();
        else
            std::cout<<404<<endl;

        // DEBUG();
    }

    Lemuen_FHQ::dfs(Lemuen_FHQ::root);

    std::cout<<ans1<<" "<<ans2<<endl;

    cerr_time;

    return 0;
}
//////////
namespace Lemuen_FHQ
{
    int merge(int x,int y)
    {
        if(!x||!y)return x+y;

        if(tr[x].rd<tr[y].rd)
        {
            tr[x].son[1]=merge(tr[x].son[1],y);
            pushup(x);return x;
        }
        else
        {
            tr[y].son[0]=merge(x,tr[y].son[0]);
            pushup(y);return y;
        }
    }

    void split(int k,int mid,int &lrt,int &rrt)
    {
        if(!k)lrt=rrt=0;
        else
        {
            if(tr[k].w<=mid)
                lrt=k,split(rs,mid,rs,rrt);
            else
                rrt=k,split(ls,mid,lrt,ls);
            pushup(k);
        }
    }

    void split_BS(int k,int mid,int &lrt,int &rrt)
    {
        if(!k)lrt=rrt=0;
        else
        {
            if(tr[k].siz<mid)
                lrt=k,split_BS(rs,mid-tr[ls].siz-1,rs,rrt);
            else
                rrt=k,split_BS(ls,mid,lrt,ls);
            pushup(k);
        }
    }

    void pushup(int k)
    {
        tr[k].siz=tr[ls].siz+tr[rs].siz+1;
    }

    void add(int w,int beu)
    {
        int lrt,rrt;

        tr[++tot].w=w;
        butf[tot]=beu;
        tr[tot].siz=1;
        tr[tot].rd=rnd();
        split(root,w,lrt,rrt);
        root=merge(merge(lrt,tot),rrt);
    }

    void del(int w)
    {
        int lrt,rrt,k;

        split(root,w,lrt,rrt);
        split(lrt,w-1,lrt,k);
        k=merge(ls,rs);
        root=merge(merge(lrt,k),rrt);
    }

    int find_n(int k,int th)
    {
        if(tr[ls].siz+1==th)
            return tr[k].w;
        else if(tr[ls].siz>=th)
            return find_n(ls,th);
        else if(tr[ls].siz<th)
            return find_n(rs,th-tr[ls].siz-1);
        return 114514;
    }
}