#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <iostream>
#include <cstdio>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned ul;
typedef long double ld;

const ul MAXN=200000;

struct point
{
    ll x,y;
    friend istream& operator>>(istream& in, point &rhs)
    {
        return in>>rhs.x>>rhs.y;
    }
    bool operator<(const point& rhs)const
    {
        return x<rhs.x||(x==rhs.x&&y<rhs.y);
    }
    bool operator==(const point& rhs)const
    {
        return x==rhs.x&&y==rhs.y;
    }
    bool operator !=(const point& rhs)const
    {
        return !(*this==rhs);
    }
};

bool cw(const point &a, const point &b, const point &c)
{
    return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x)<0;
}

bool ccw(const point &a, const  point &b, const  point &c)
{
    return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x)>0;
}

void convex_hull(point* a, int &a_size)
{
    if(a_size==1)return;
    sort(a,a+a_size);
    point p1=a[0],p2=a[a_size-1];
    static point up[MAXN],down[MAXN];
    int up_size,down_size;
    up_size=down_size=1;
    up[0]=down[0]=p1;
    for(int i=1;i<a_size;++i)
    {
        if(i==a_size-1||cw(p1,a[i],p2))
        {
            while(up_size>=2&&!cw(up[up_size-2],up[up_size-1],a[i]))
                up_size--;
            up[up_size++]=a[i];
        }
        if(i==a_size-1||ccw(p1,a[i],p2))
        {
            while(down_size>=2&&!ccw(down[down_size-2],down[down_size-1],a[i]))
                down_size--;
            down[down_size++]=a[i];
        }
    }
    a_size=0;
    for(int i=0;i<up_size;++i)
        a[a_size++]=up[i];
    for(int i=down_size-2;i>0;--i)
        a[a_size++]=down[i];
}

bool point_on_segment(point pt, point seg1,point seg2)
{
    if(!(seg1<seg2))swap(seg1,seg2);
    return (!cw(seg1,pt,seg2)&&!ccw(seg1,pt,seg2)&&!(pt<seg1)&&(pt<seg2||pt==seg2));
}

int normalize(int a, int max_a)
{
    while(a<0)a+=max_a;
    return a%max_a;
}

int main()
{
    int K;
    cin>>K;
    while(K--)
    {
        int n,hull_size;
        bool f=true;
        bool onOneLine=true;
        cin>>n;
        static point a[MAXN],b[MAXN];
        int simple_check=0;
        bool fast_res=false;
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
            if(i&&a[i]==a[i-1]){--i;--n;}
            b[i]=a[i];
        }
        hull_size=n;
        for(int i=0;i<n+5&&!fast_res;i++)
        {
            if(!simple_check)
            {
                simple_check=cw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)])-ccw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)]);
            }
            else
            {
                fast_res=simple_check*(cw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)])-ccw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)]))<0;
            }
            onOneLine=onOneLine&&(!cw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)])&&!ccw(a[normalize(i,n)],a[normalize(i+1,n)],a[normalize(i+2,n)]));
        }
        if(fast_res){cout<<"0 ";continue;}
        convex_hull(b,hull_size);
        int direction;
        int i_start=0;
        int current=find(a,a+n,b[i_start])-a;
        int n_same=0;
        while(a[current]==a[normalize(current+1,n)]&&n_same<=n)current=normalize(current+1,n),n_same++;
        if(n_same>n)
        {cout<<1<<" ";continue;}
        if(point_on_segment(a[normalize(current+1,n)],b[i_start],b[normalize(i_start+1,hull_size)]))direction=1;
        else if(point_on_segment(a[normalize(current+1,n)],b[i_start],b[normalize(i_start-1,hull_size)]))direction=-1;
        int i,next_hull,next;
        for(i=i_start;f&&i<hull_size;current+=direction,++i)
        {
            while(a[current]==a[normalize(current+direction,n)])
                current=normalize(current+direction,n);
            i=normalize(i,hull_size);
            next=normalize(i+1,hull_size);
            next_hull=normalize(current+direction,n);
            current=normalize(current,n);
            if(point_on_segment(a[next_hull],a[current],b[next]))
            {
                if(a[next_hull]!=b[next])i--;
            }else {cout<<0<<" ";f=false;}
        }
        if(f)
            cout<<"1 ";
    }
}