Gopu is interested in the integer co-ordinates of the X-Y plane (0<=x,y<=100000). Each integer coordinate contain a lamp, initially all the lamps are in off mode. Flipping a lamp means switching it on if it is in off mode and vice versa. Maggu will ask gopu 3 type of queries.

Type 1:  x l r,  meaning: flip all the lamps whose x-coordinate are between l and r (both inclusive) irrespective of the y coordinate.

Type 2:  y l r, meaning: flip all the lamps whose y-coordinate are between l and r (both inclusive) irrespective of the x coordinate.

Type 3: q x y X Y, meaning: count the number of lamps which are in ‘on mode’(say this number be A) and ‘off mode’ (say this number  be B) in the region where x-coordinate is between x and X(both inclusive) and y-coordinate is between y and Y(both inclusive).

Input

First line contains Q-number of queries that maggu will ask to gopu. (Q <= 10^5)

Then there will be Q lines each containing a query of one of the three type described above.

Output

For each query of 3rd type you need to output a line containing one integer A.

Example

Input:

3

x 0 1

y 1 2

q 0 0 2 2

Output: 

 4

#pragma comment(linker, "/STACK:1024000000,1024000000")

#include<iostream>

#include<cstdio>

#include<cmath>

#include<string>

#include<queue>

#include<algorithm>

#include<stack>

#include<cstring>

#include<vector>

#include<list>

#include<set>

#include<map>

using namespace std;

#define ll long long

#define pi (4*atan(1.0))

#define mk make_pair

#define eps 1e-7

#define bug(x)  cout<<"bug"<<x<<endl;

const int N=5e5+,M=1e6+,inf=;

const ll INF=1e18+,mod=;

///   数组大小

struct SGT

{

    int tree[N],lazy[N];

    void pushup(int pos)

    {

        tree[pos]=tree[pos<<|]+tree[pos<<];

    }

    void pushdown(int pos,int l,int r)

    {

        if(lazy[pos])

        {

            lazy[pos<<]^=;

            lazy[pos<<|]^=;

            int mid=(l+r)>>;

            tree[pos<<]=(mid-l+)-tree[pos<<];

            tree[pos<<|]=(r-mid)-tree[pos<<|];

            lazy[pos]=;

        }

    }

    void build(int l,int r,int pos)

    {

        tree[pos]=lazy[pos]=;

        if(l==r)return;

        int mid=(l+r)>>;

        build(l,mid,pos<<);

        build(mid+,r,pos<<|);

    }

    void update(int L,int R,int l,int r,int pos)

    {

        if(L<=l&&r<=R)

        {

            lazy[pos]^=;

            tree[pos]=(r-l+)-tree[pos];

            return;

        }

        pushdown(pos,l,r);

        int mid=(l+r)>>;

        if(L<=mid)

            update(L,R,l,mid,pos<<);

        if(R>mid)

            update(L,R,mid+,r,pos<<|);

        pushup(pos);

    }

    int query(int L,int R,int l,int r,int pos)

    {

        if(L<=l&&r<=R)

            return tree[pos];

        pushdown(pos,l,r);

        int mid=(l+r)>>;

        int ans=;

        if(L<=mid)

            ans+=query(L,R,l,mid,pos<<);

        if(R>mid)

            ans+=query(L,R,mid+,r,pos<<|);

        return ans;

    }

};

SGT x,y;

char ch[];

int main()

{

    int q;

    int n=;

    while(~scanf("%d",&q))

    {

        x.build(,n,);

        y.build(,n,);

        while(q--)

        {

            int l,r;

            scanf("%s%d%d",ch,&l,&r);

            //if(l<r)swap(l,r);

            if(ch[]=='x')

                x.update(l+,r+,,n,);

            else if(ch[]=='y')

                y.update(l+,r+,,n,);

            else

            {

                int L,R;

                scanf("%d%d",&L,&R);

                //if(L<R)swap(L,R);

                int xx=x.query(l+,L+,,n,);

                int yy=y.query(r+,R+,,n,);

                ll ans=;

                ans+=1LL*xx*(R-r+);

                ans+=1LL*yy*(L-l+);

                ans-=2LL*xx*yy;

                printf("%lld\n",ans);

            }

        }

    }

    return ;

}