#include<bits/stdc++.h>
using namespace std;
 
using ll=long long;
#define fs first
#define sd second
 
const int N=5e5+1e3+7;
 
struct P {
    int x,y;
}a[N],b[N];
 
bool operator <(const P &a,const P &b)
{
    return a.x<b.x||(a.x==b.x&&a.y<b.y);
}
 
bool operator ==(const P &a,const P &b)
{
    return !(a<b)&&!(b<a);
}
 
P operator -(const P &a,const P &b)
{
    return {a.x-b.x,a.y-b.y};
}
 
ll operator *(const P &a,const P &b)
{
    return 1ll*a.x*b.y-1ll*a.y*b.x;
}
 
ll operator ^(const P &a,const P &b)
{
    return 1ll*a.x*b.x+1ll*a.y*b.y;
}
 
using L=pair<P,P>;
 
int T,n;
 
L mod[N];
 
tuple<int,int,int> e[N];
 
int to[N];
 
int phase(const P &a)
{
    if(a.y!=0)
        return a.y<0;
    return a.x<0;
}
 
bool cmp(const P &a,const P &b)
{
    int pa=phase(a),pb=phase(b);
    if(pa!=pb)
        return pa<pb;
    return a*b>0;
}
 
struct T{
    L lv,rv;
    int ok,cnt;
}t[N*4+1];
 
bool chk(const L &a,const L &b)
{
    if(a==b)
        return 1;
    P u=a.sd-a.fs,v=b.sd-b.fs,w=b.fs-a.sd;
    if(w.x==0&&w.y==0)
        return u*v>0;
    return (u*w>0||(u*w==0&&(u^w)>0))&&(w*v>0||(w*v==0&&(w^v)>0));
}
 
void update(int x)
{
    if(!t[x<<1].cnt)
        t[x]=t[x<<1|1];
    else if(!t[x<<1|1].cnt)
        t[x]=t[x<<1];
    else
    {
        t[x].lv=t[x<<1].lv,t[x].rv=t[x<<1|1].rv;
        t[x].ok=t[x<<1].ok&&t[x<<1|1].ok&&chk(t[x<<1].rv,t[x<<1|1].lv);
        t[x].cnt=t[x<<1].cnt+t[x<<1|1].cnt;
    }
}
 
int id[N];
 
int st[N];
 
multiset<P> seg[N];
 
void adj(L &a,L b)
{
    ll f=(a.sd-a.fs)*(b.fs-a.fs);
    if(f)
    {
        if(f<0)
            swap(a.fs,a.sd);
    }
    else
    {
        f=(a.sd-a.fs)*(b.sd-a.fs);
        if(f<0)
            swap(a.fs,a.sd);
    }
}
 
int m;
 
void modify(int p,L u)
{
    int x=p+m-1;
    if(u.fs==u.sd)
        t[x].cnt=0;
    else
        t[x].ok=1,t[x].cnt=1,t[x].lv=t[x].rv=u;
    x>>=1;
    while(x)
    {
        update(x);
        x>>=1;
    }
}
 
struct MODIFY{
    int r;
    L u;
    int c;
};
 
vector<MODIFY> ch[N],rch[N];
 
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>T;
    while(T--)
    {
        cin>>n;
        vector<tuple<int,int,int> >X;
        for(int i=1;i<=n;i++)
        {
            string op;
            cin>>op;
            if(op=="+")
            {
                cin>>a[i].x>>a[i].y>>b[i].x>>b[i].y;
                ll A=a[i].y-b[i].y,B=b[i].x-a[i].x,C=-1ll*b[i].y*a[i].x+1ll*a[i].y*b[i].x;
                ll g=__gcd(__gcd(A,B),C);
                A/=g,B/=g,C/=g;
                if(A<0||(A==0&&B<0))
                    A*=-1,B*=-1,C*=-1;
                g=abs(__gcd(A,B));
                e[i]={A,B,C};
                X.push_back(e[i]);
            }
            else
            {
                cin>>a[i].x;
                a[i].y=0;
                b[i]=a[i];
            }
        }
        sort(X.begin(),X.end());
        X.erase(unique(X.begin(),X.end()),X.end());
        for(int i=1;i<=X.size();i++)
            seg[i].clear(),st[i]=0;
        for(int i=1;i<=n;i++)
            ch[i].clear(),rch[i].clear();
        for(int i=1;i<=n;i++)
        {
            if(a[i]==b[i])
            {
                int x=id[a[i].x];
                id[i]=x;
                int j=a[i].x;
                seg[x].erase(seg[x].find(a[j]));
                seg[x].erase(seg[x].find(b[j]));
                ch[st[x]].push_back({i-1,mod[st[x]],x});
                if(!seg[x].size())
                    st[x]=0;
                else
                    st[x]=i,mod[i]={*seg[x].begin(),*--seg[x].end()};
            }
            else
            {
                id[i]=lower_bound(X.begin(),X.end(),e[i])-X.begin()+1;
                int x=id[i];
                seg[x].insert(a[i]),seg[x].insert(b[i]);
                mod[i]={*seg[x].begin(),*--seg[x].end()};
                if(st[x])
                    ch[st[x]].push_back({i-1,mod[st[x]],x});
                st[x]=i;
            }
        }
        for(int i=1;i<=X.size();i++)
            if(st[i])
            {
                ch[st[i]].push_back({n,mod[st[i]],i});
                mod[n+1]=mod[st[i]];
            }
        MODIFY mx,smx,rem;
        mx.r=smx.r=-1;
        rem.c=-1;
        for(int i=1;i<=n;i++)
        {
            if(!ch[i].size())
                continue;
            if(rem.c!=-1)
            {
                if(rem.r>=i)
                    ch[i].push_back(rem);
                rem.c=-1;
            }
            sort(ch[i].begin(),ch[i].end(),[&](const MODIFY &u,const MODIFY &v){return u.r>v.r;});
            for(auto [r,u,c]:ch[i])
            {
                MODIFY v={r,u,c};
                if(v.r>mx.r)
                    swap(mx,v);
                if(v.r>smx.r)
                    swap(smx,v);
                if(mx.c==smx.c)
                    swap(v,smx);
            }
            for(auto [r,u,c]:ch[i])
            {
                MODIFY dir;
                if(mx.c!=c)
                    dir=mx;
                else if(smx.c!=c)
                    dir=smx;
                else
                    dir.c=-1;
                if(dir.c==-1||dir.r<i)
                    rem={r,u,c};
                else
                {
                    adj(u,dir.u);
                    rch[i].push_back({min(dir.r,r),u,c});
                    if(dir.r<r)
                        ch[dir.r+1].push_back({r,u,c});
                }
            }
        }
        vector<P> v;
 
        for(int i=1;i<=n;i++)
            for(auto [r,u,c]:rch[i])
                v.push_back({u.sd-u.fs});
        sort(v.begin(),v.end(),cmp);
 
        vector<int> ct(v.size());
        for(int i=1;i<=n;i++)
            ch[i].clear();
        for(int i=1;i<=n;i++)
            for(auto [r,u,c]:rch[i])
            {
                int p=lower_bound(v.begin(),v.end(),u.sd-u.fs,cmp)-v.begin();
                ++ct[p];
                ch[i].push_back({p+ct[p],u,c});
                ch[r+1].push_back({-(p+ct[p]),u,c});
            }
        m=1;
        while(m<v.size())
            m<<=1;
        for(int i=1;i<=m*2-1;i++)
            t[i].cnt=0,t[i].ok=1;
        for(int i=1;i<=n;i++)
        {
            for(auto [r,u,c]:ch[i])
            {
                if(r>0)
                    modify(r,u);
                else
                    modify(-r,{{0,0},{0,0}});
            }
            if(t[1].cnt<=1||(t[1].ok&&chk(t[1].rv,t[1].lv)))
                cout<<1;
            else
                cout<<0;
        }
        cout<<"\n";
    }
 
}